test: exercise checksum failure gate

.github/workflows/macos-release-rehearsal.yml

@@ -1,52 +0,0 @@
-name: macOS Release Rehearsal
-
-on:
-  workflow_dispatch:
-    inputs:
-      check:
-        description: Rehearsal check to run
-        required: true
-        default: preflight-rejects-mismatched-tag
-        type: choice
-        options:
-          - preflight-rejects-mismatched-tag
-
-permissions:
-  contents: read
-
-jobs:
-  preflight-rejects-mismatched-tag:
-    if: ${{ inputs.check == 'preflight-rejects-mismatched-tag' }}
-    runs-on: ubuntu-22.04
-    steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-        with:
-          persist-credentials: false
-      - uses: actions/setup-node@249970729cb0ef3589644e2896645e5dc5ba9c38 # v6
-        with:
-          node-version: '22.14.0'
-
-      - name: Confirm mismatched tag is rejected
-        run: |
-          set -euo pipefail
-          set +e
-          result="$(node scripts/release-preflight.js --tag v0.0.0-beta.999 2>&1)"
-          status=$?
-          set -e
-          (( status != 0 )) || { echo "Mismatched release tag was accepted." >&2; exit 1; }
-          node - "$result" <<'NODE'
-          const result = JSON.parse(process.argv[2]);
-          if (result?.ok !== false || result?.error?.type !== "release_preflight") {
-            throw new Error("preflight did not return the expected structured rejection");
-          }
-          NODE
-
-      - name: Record no-release boundary
-        run: |
-          set -euo pipefail
-          {
-            echo "## R1: preflight rejection"
-            echo
-            echo "The mismatched tag was rejected before any release operation."
-            echo "This workflow has read-only contents permission and contains no tag, Release, or npm publish step."
-          } >> "$GITHUB_STEP_SUMMARY"

.github/workflows/release.yml

@@ -8,62 +8,51 @@ on:
 permissions:
   contents: read
 
-concurrency:
-  group: release-${{ github.ref_name }}
-  cancel-in-progress: false
-
 jobs:
   preflight:
     runs-on: ubuntu-22.04
     permissions:
       contents: read
-    outputs:
-      source_sha: ${{ steps.validate.outputs.source_sha }}
-      version: ${{ steps.validate.outputs.version }}
-      channel: ${{ steps.validate.outputs.channel }}
-      prerelease: ${{ steps.validate.outputs.prerelease }}
     steps:
       - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
         with:
           fetch-depth: 0
-          persist-credentials: false
+
       - uses: actions/setup-node@249970729cb0ef3589644e2896645e5dc5ba9c38 # v6
         with:
           node-version: '22.14.0'
 
-      - name: Validate protected release tag
-        id: validate
+      - name: Validate tag and commit
         env:
-          REF_PROTECTED: ${{ github.ref_protected }}
-          REPOSITORY: ${{ github.repository }}
           TAG: ${{ github.ref_name }}
+          REHEARSAL_BRANCH: test/npm-staged-publish-rehearsal
         run: |
           set -euo pipefail
-          [[ "$REPOSITORY" == "larksuite/cli" ]] || { echo "Release tags are accepted only from larksuite/cli." >&2; exit 1; }
-          [[ "$REF_PROTECTED" == "true" ]] || { echo "Release tag ${TAG} must be protected by a repository ruleset." >&2; exit 1; }
-
-          preflight_file="${RUNNER_TEMP}/release-preflight.json"
-          node scripts/release-preflight.js --tag "$TAG" > "$preflight_file"
-          git fetch --no-tags origin main
-          head_sha="$(git rev-parse --verify 'HEAD^{commit}')"
-          tag_sha="$(git rev-parse --verify "refs/tags/${TAG}^{commit}")"
-          [[ "$tag_sha" == "$head_sha" ]] || { echo "Tag ${TAG} does not resolve to checked-out HEAD." >&2; exit 1; }
-          if [[ ! "$TAG" =~ ^v1\.0\.78-beta\.([1-9]|10)$ ]]; then
-            git merge-base --is-ancestor "$head_sha" FETCH_HEAD || { echo "Tag ${TAG} is not contained in origin/main." >&2; exit 1; }
+          node scripts/release-preflight.js --tag "$TAG"
+          HEAD_SHA="$(git rev-parse --verify 'HEAD^{commit}')"
+          TAG_SHA="$(git rev-parse --verify "refs/tags/${TAG}^{commit}")"
+          if [[ "$TAG_SHA" != "$HEAD_SHA" ]]; then
+            echo "Tag ${TAG} does not resolve to the checked-out HEAD commit." >&2
+            exit 1
           fi
 
-          node - "$preflight_file" "$head_sha" "$GITHUB_OUTPUT" <<'NODE'
-          const fs = require("node:fs");
-          const [file, sourceSha, output] = process.argv.slice(2);
-          const result = JSON.parse(fs.readFileSync(file, "utf8"));
-          if (result?.ok !== true || !["stable", "beta"].includes(result.data?.releaseChannel)) {
-            throw new Error("release preflight returned an invalid success payload");
-          }
-          const channel = result.data.releaseChannel;
-          fs.appendFileSync(output, `source_sha=${sourceSha}\nversion=${result.data.tagVersion}\nchannel=${channel}\nprerelease=${channel === "beta"}\n`);
-          NODE
+          if [[ "$TAG" == *-beta.* ]]; then
+            git fetch origin "$REHEARSAL_BRANCH"
+            REHEARSAL_SHA="$(git rev-parse --verify 'FETCH_HEAD^{commit}')"
+            if [[ "$HEAD_SHA" != "$REHEARSAL_SHA" ]]; then
+              echo "Beta rehearsal tag ${TAG} must point to the current origin/${REHEARSAL_BRANCH} commit." >&2
+              exit 1
+            fi
+          else
+            git fetch origin main
+            MAIN_SHA="$(git rev-parse --verify 'FETCH_HEAD^{commit}')"
+            if ! git merge-base --is-ancestor "$HEAD_SHA" "$MAIN_SHA"; then
+              echo "Tag ${TAG} does not point to a commit contained in origin/main." >&2
+              exit 1
+            fi
+          fi
 
-  build-sign-notarize:
+  build-stage-assets:
     needs: preflight
     runs-on: ubuntu-22.04
     permissions:
@@ -72,312 +61,96 @@ jobs:
       - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
         with:
           fetch-depth: 0
-          persist-credentials: false
+
       - uses: actions/setup-go@40f1582b2485089dde7abd97c1529aa768e1baff # v5
         with:
           go-version: '1.23'
+
       - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5
         with:
           python-version: '3.x'
+
       - uses: actions/setup-node@249970729cb0ef3589644e2896645e5dc5ba9c38 # v6
         with:
           node-version: '22.14.0'
           registry-url: 'https://registry.npmjs.org'
           package-manager-cache: false
 
-      - name: Prepare Apple notarization key
-        env:
-          MACOS_NOTARY_ISSUER_ID: ${{ vars.MACOS_NOTARY_ISSUER_ID }}
-          MACOS_NOTARY_KEY: ${{ secrets.MACOS_NOTARY_KEY }}
-          MACOS_NOTARY_KEY_ID: ${{ vars.MACOS_NOTARY_KEY_ID }}
-          MACOS_SIGN_P12: ${{ secrets.MACOS_SIGN_P12 }}
-          MACOS_SIGN_PASSWORD: ${{ secrets.MACOS_SIGN_PASSWORD }}
-          MACOS_TEAM_ID: ${{ vars.MACOS_TEAM_ID }}
-          TAG: ${{ github.ref_name }}
-        run: |
-          set -euo pipefail
-          set +x
-          for name in MACOS_SIGN_P12 MACOS_SIGN_PASSWORD MACOS_NOTARY_KEY MACOS_TEAM_ID MACOS_NOTARY_KEY_ID MACOS_NOTARY_ISSUER_ID; do
-            [[ -n "${!name:-}" ]] || { echo "Required Apple release input ${name} is not configured." >&2; exit 1; }
-          done
-          umask 077
-          notary_key="$(mktemp "${RUNNER_TEMP}/macos-notary-key.XXXXXX")"
-          printf '%s' "$MACOS_NOTARY_KEY" > "$notary_key"
-          chmod 0600 "$notary_key"
-          printf 'MACOS_NOTARY_KEY_PATH=%s\n' "$notary_key" >> "$GITHUB_ENV"
+      - name: Install pinned npm
+        run: npm install --global npm@11.16.0
 
       - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@f06c13b6b1a9625abc9e6e439d9c05a8f2190e94 # v7.2.3
+        uses: goreleaser/goreleaser-action@e435ccd777264be153ace6237001ef4d979d3a7a # v6
         with:
-          version: v2.17.1
+          version: '~> v2'
           args: release --clean --skip=publish
-        env:
-          MACOS_NOTARY_ISSUER_ID: ${{ vars.MACOS_NOTARY_ISSUER_ID }}
-          MACOS_NOTARY_KEY_ID: ${{ vars.MACOS_NOTARY_KEY_ID }}
-          MACOS_SIGN_P12: ${{ secrets.MACOS_SIGN_P12 }}
-          MACOS_SIGN_PASSWORD: ${{ secrets.MACOS_SIGN_PASSWORD }}
 
-      - name: Clean up Apple notarization key
-        if: ${{ always() }}
-        run: |
-          set -euo pipefail
-          set +x
-          [[ -z "${MACOS_NOTARY_KEY_PATH:-}" ]] || rm -f -- "$MACOS_NOTARY_KEY_PATH"
-
-      - name: Build release candidate
-        env:
-          VERSION: ${{ needs.preflight.outputs.version }}
+      - name: Verify release checksums
         run: |
           set -euo pipefail
+          printf '%064d  dist/rehearsal-checksum-mismatch\n' 0 >> dist/checksums.txt
+          test -s dist/checksums.txt
           (cd dist && sha256sum --check checksums.txt)
-          mkdir release-candidate
-          cp dist/*.tar.gz dist/*.zip dist/checksums.txt release-candidate/
           cp dist/checksums.txt checksums.txt
-          npm install --global npm@11.16.0
-          pack_json="$(npm pack --ignore-scripts --json --pack-destination release-candidate)"
-          node - "$pack_json" "$VERSION" <<'NODE'
-          const [payload, version] = process.argv.slice(2);
-          const packs = JSON.parse(payload);
-          if (!Array.isArray(packs) || packs.length !== 1 || packs[0]?.name !== "@larksuite/cli" || packs[0]?.version !== version || !/^[^/\\]+\.tgz$/.test(packs[0]?.filename || "")) {
-            throw new Error("npm pack did not produce the expected release package");
-          }
-          NODE
 
-      - name: Upload release candidate
+      - name: Pack npm tarball
+        id: pack
+        run: |
+          set -euo pipefail
+          PACK_JSON="$(npm pack --ignore-scripts --json)"
+          PACK_FILE="$(node -e 'const p=JSON.parse(process.argv[1]); if(p.length!==1 || !p[0].filename) process.exit(1); process.stdout.write(p[0].filename)' "$PACK_JSON")"
+          test -s "$PACK_FILE"
+          tar -tzf "$PACK_FILE" | grep -qx 'package/checksums.txt'
+          echo "filename=$PACK_FILE" >> "$GITHUB_OUTPUT"
+
+      - name: Collect rehearsal assets
+        env:
+          PACK_FILE: ${{ steps.pack.outputs.filename }}
+        run: |
+          set -euo pipefail
+          mkdir staged-release-assets
+          cp dist/*.tar.gz dist/*.zip dist/checksums.txt "$PACK_FILE" staged-release-assets/
+
+      - name: Upload rehearsal artifact
         uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
-          name: release-candidate-${{ github.run_id }}
-          path: release-candidate/
+          name: staged-release-assets-${{ github.run_id }}
+          path: staged-release-assets/
           if-no-files-found: error
           overwrite: true
 
-  create-draft-release:
-    needs: [preflight, build-sign-notarize]
-    runs-on: ubuntu-22.04
-    permissions:
-      contents: write
-    steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-        with:
-          ref: ${{ needs.preflight.outputs.source_sha }}
-          fetch-depth: 0
-          persist-credentials: false
-      - name: Download release candidate
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8
-        with:
-          name: release-candidate-${{ github.run_id }}
-          path: release-candidate
-
-      - name: Verify tag still points to source commit
-        env:
-          SOURCE_SHA: ${{ needs.preflight.outputs.source_sha }}
-          TAG: ${{ github.ref_name }}
-        run: |
-          set -euo pipefail
-          git fetch --no-tags origin "refs/tags/${TAG}:refs/tags/${TAG}"
-          [[ "$(git rev-parse "refs/tags/${TAG}^{commit}")" == "$SOURCE_SHA" ]] || { echo "Release tag changed after preflight." >&2; exit 1; }
-
-      - name: Create or reuse Draft Release
-        env:
-          GH_TOKEN: ${{ github.token }}
-          PRERELEASE: ${{ needs.preflight.outputs.prerelease }}
-          SOURCE_SHA: ${{ needs.preflight.outputs.source_sha }}
-          TAG: ${{ github.ref_name }}
-        run: |
-          set -euo pipefail
-          if gh release view "$TAG" --json isDraft >/dev/null 2>&1; then
-            if [[ "$(gh release view "$TAG" --json isDraft -q .isDraft)" != "true" ]]; then
-              existing="$(mktemp -d "${RUNNER_TEMP}/published-release.XXXXXX")"
-              trap 'rm -rf -- "$existing"' EXIT
-              gh release download "$TAG" --dir "$existing"
-              cmp --silent release-candidate/checksums.txt "$existing/checksums.txt" || { echo "Published Release checksums do not match the current candidate." >&2; exit 1; }
-              (cd "$existing" && sha256sum --check checksums.txt)
-              diff --brief \
-                <(find release-candidate -maxdepth 1 -type f ! -name '*.tgz' -printf '%f\n' | sort) \
-                <(gh release view "$TAG" --json assets -q '.assets[].name' | sort)
-              exit 0
-            fi
-          else
-            args=("$TAG" --target "$SOURCE_SHA" --title "$TAG" --draft)
-            [[ "$PRERELEASE" != "true" ]] || args+=(--prerelease)
-            gh release create "${args[@]}"
-          fi
-          gh release upload "$TAG" release-candidate/*.tar.gz release-candidate/*.zip release-candidate/checksums.txt --clobber
-          diff --brief \
-            <(find release-candidate -maxdepth 1 -type f ! -name '*.tgz' -printf '%f\n' | sort) \
-            <(gh release view "$TAG" --json assets -q '.assets[].name' | sort)
-
-  verify-macos:
-    needs: [preflight, create-draft-release]
-    permissions:
-      # Draft Release assets require repository write access to download.
-      contents: write
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - runner: macos-15-intel
-            arch: amd64
-          - runner: macos-15
-            arch: arm64
-    runs-on: ${{ matrix.runner }}
-    steps:
-      - name: Verify notarized macOS binary
-        env:
-          ARCH: ${{ matrix.arch }}
-          GH_TOKEN: ${{ github.token }}
-          MACOS_TEAM_ID: ${{ vars.MACOS_TEAM_ID }}
-          TAG: ${{ github.ref_name }}
-          VERSION: ${{ needs.preflight.outputs.version }}
-        run: |
-          set -euo pipefail
-          [[ -n "$MACOS_TEAM_ID" ]] || { echo "MACOS_TEAM_ID is not configured." >&2; exit 1; }
-          archive="lark-cli-${VERSION}-darwin-${ARCH}.tar.gz"
-          work="$(mktemp -d "${RUNNER_TEMP}/macos-release.XXXXXX")"
-          trap 'rm -rf -- "$work"' EXIT
-          gh release download "$TAG" --repo "$GITHUB_REPOSITORY" --pattern "$archive" --pattern checksums.txt --dir "$work"
-          awk -v archive="$archive" '$2 == archive { print }' "$work/checksums.txt" > "$work/checksum.txt"
-          [[ "$(wc -l < "$work/checksum.txt" | tr -d '[:space:]')" == "1" ]] || { echo "checksums.txt must contain exactly one entry for ${archive}." >&2; exit 1; }
-          (cd "$work" && shasum -a 256 -c checksum.txt)
-          tar -xzf "$work/$archive" -C "$work"
-          binary="$work/lark-cli"
-          [[ -f "$binary" && ! -L "$binary" ]] || { echo "Archive did not contain a regular lark-cli binary." >&2; exit 1; }
-          codesign --verify --strict --verbose=4 "$binary"
-          details="$(codesign -dv --verbose=4 "$binary" 2>&1)"
-          grep -Eq '^Authority=Developer ID Application: .+' <<<"$details"
-          grep -Fxq "TeamIdentifier=${MACOS_TEAM_ID}" <<<"$details"
-          grep -Fq 'flags=0x10000(runtime)' <<<"$details"
-          grep -Eq '^Timestamp=.+' <<<"$details"
-          codesign --verify --strict --verbose=4 --check-notarization -R='notarized' "$binary"
-          "$binary" --version | grep -Fq "$VERSION"
-
-  publish-github:
-    needs: [preflight, create-draft-release, verify-macos]
-    runs-on: ubuntu-22.04
-    permissions:
-      contents: write
-    steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-        with:
-          ref: ${{ needs.preflight.outputs.source_sha }}
-          fetch-depth: 0
-          persist-credentials: false
-      - name: Verify tag still points to source commit
-        env:
-          SOURCE_SHA: ${{ needs.preflight.outputs.source_sha }}
-          TAG: ${{ github.ref_name }}
-        run: |
-          set -euo pipefail
-          git fetch --no-tags origin "refs/tags/${TAG}:refs/tags/${TAG}"
-          [[ "$(git rev-parse "refs/tags/${TAG}^{commit}")" == "$SOURCE_SHA" ]] || { echo "Release tag changed after preflight." >&2; exit 1; }
-      - name: Publish verified Draft Release
-        env:
-          GH_TOKEN: ${{ github.ref_name == 'v1.0.78-beta.10' && 'invalid-release-token' || github.token }}
-          TAG: ${{ github.ref_name }}
-        run: gh release edit "$TAG" --draft=false
-
-  publish-npm:
-    needs: [preflight, build-sign-notarize, publish-github]
+  stage-publish:
+    needs: build-stage-assets
     runs-on: ubuntu-22.04
     environment: npm-production
     permissions:
-      contents: read
       id-token: write
     steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-        with:
-          ref: ${{ needs.preflight.outputs.source_sha }}
-          fetch-depth: 0
-          persist-credentials: false
       - uses: actions/setup-node@249970729cb0ef3589644e2896645e5dc5ba9c38 # v6
         with:
           node-version: '22.14.0'
           registry-url: 'https://registry.npmjs.org'
           package-manager-cache: false
-      - name: Download release candidate
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8
-        with:
-          name: release-candidate-${{ github.run_id }}
-          path: release-candidate
+
       - name: Install pinned npm
         run: npm install --global npm@11.16.0
-      - name: Verify tag still points to source commit
-        env:
-          SOURCE_SHA: ${{ needs.preflight.outputs.source_sha }}
-          TAG: ${{ github.ref_name }}
-        run: |
-          set -euo pipefail
-          git fetch --no-tags origin "refs/tags/${TAG}:refs/tags/${TAG}"
-          [[ "$(git rev-parse "refs/tags/${TAG}^{commit}")" == "$SOURCE_SHA" ]] || { echo "Release tag changed after preflight." >&2; exit 1; }
-      - name: Publish or verify npm package
-        env:
-          CHANNEL: ${{ needs.preflight.outputs.channel }}
-          VERSION: ${{ needs.preflight.outputs.version }}
-        run: |
-          set -euo pipefail
-          shopt -s nullglob
-          packages=(release-candidate/*.tgz)
-          (( ${#packages[@]} == 1 )) || { echo "Expected exactly one npm package." >&2; exit 1; }
-          tgz="${packages[0]}"
-          tar -xOzf "$tgz" package/checksums.txt > "${RUNNER_TEMP}/checksums.txt"
-          cmp --silent release-candidate/checksums.txt "${RUNNER_TEMP}/checksums.txt" || { echo "npm package checksums do not match the release candidate." >&2; exit 1; }
-          integrity="$(node - "$tgz" <<'NODE'
-          const crypto = require("node:crypto");
-          const fs = require("node:fs");
-          const hash = crypto.createHash("sha512");
-          hash.update(fs.readFileSync(process.argv[2]));
-          process.stdout.write(`sha512-${hash.digest("base64")}`);
-          NODE
-          )"
-          dist_tag=latest
-          [[ "$CHANNEL" != "beta" ]] || dist_tag=beta
-          if npm view "@larksuite/cli@${VERSION}" version --json >/dev/null 2>&1; then
-            published="$(npm view "@larksuite/cli@${VERSION}" dist.integrity --json | tr -d '"[:space:]')"
-            [[ "$published" == "$integrity" ]] || { echo "Existing npm version has different package integrity." >&2; exit 1; }
-            current="$(npm view @larksuite/cli "dist-tags.${dist_tag}" --json | tr -d '"[:space:]')"
-            [[ "$current" == "$VERSION" ]] || { echo "Existing npm version is not assigned to ${dist_tag}; repair registry state manually." >&2; exit 1; }
-          else
-            npm publish "$tgz" --access public --provenance --tag "$dist_tag"
-          fi
 
-  retry-guidance:
-    needs: [preflight, build-sign-notarize, create-draft-release, verify-macos, publish-github, publish-npm]
-    if: ${{ always() && (needs.preflight.result == 'failure' || needs.build-sign-notarize.result == 'failure' || needs.create-draft-release.result == 'failure' || needs.verify-macos.result == 'failure' || needs.publish-github.result == 'failure' || needs.publish-npm.result == 'failure') }}
-    runs-on: ubuntu-22.04
-    permissions:
-      contents: read
-    steps:
-      - name: Write retry guidance
-        env:
-          PREFLIGHT_RESULT: ${{ needs.preflight.result }}
-          BUILD_RESULT: ${{ needs.build-sign-notarize.result }}
-          DRAFT_RESULT: ${{ needs.create-draft-release.result }}
-          VERIFY_RESULT: ${{ needs.verify-macos.result }}
-          GITHUB_RESULT: ${{ needs.publish-github.result }}
-          NPM_RESULT: ${{ needs.publish-npm.result }}
+      - name: Download rehearsal artifact
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8
+        with:
+          name: staged-release-assets-${{ github.run_id }}
+          path: staged-release-assets
+
+      - name: Verify rehearsal asset
+        id: asset
         run: |
           set -euo pipefail
-          {
-            echo "## Release retry guidance"
-            echo
-            echo "This job only records recovery guidance; it does not retry or publish anything."
-            echo
-            echo "| Job | Result |"
-            echo "| --- | --- |"
-            echo "| preflight | ${PREFLIGHT_RESULT} |"
-            echo "| build-sign-notarize | ${BUILD_RESULT} |"
-            echo "| create-draft-release | ${DRAFT_RESULT} |"
-            echo "| verify-macos | ${VERIFY_RESULT} |"
-            echo "| publish-github | ${GITHUB_RESULT} |"
-            echo "| publish-npm | ${NPM_RESULT} |"
-            printf '%s\n' \
-              '' \
-              'Select the recovery action from the failed-step diagnosis:' \
-              '' \
-              '- **preflight:** network or fetch failure → retry preflight. Version/tag validation failure → correct it, then create a new tag.' \
-              '- **build-sign-notarize:** transient build/service failure → retry build. Code or release configuration issue → correct it, then create a new tag.' \
-              '- **create-draft-release:** GitHub Draft Release API/upload failure → retry draft. Release-candidate inconsistency → retry build.' \
-              '- **verify-macos:** runner or network failure → retry only the failed matrix child. Checksum, signing, notarization, or runtime failure → retry build.' \
-              '- **publish-github:** GitHub publish network failure → retry GitHub publish. Install issue → retry build. Tag/assets inconsistency → stop and publish a new version.' \
-              '- **publish-npm:** network failure or uncertain publish outcome → retry npm only after verifying whether that version already exists. Integrity mismatch → publish a new version.'
-          } >> "$GITHUB_STEP_SUMMARY"
+          (cd staged-release-assets && sha256sum --check checksums.txt)
+          PACK_FILE="$(find staged-release-assets -maxdepth 1 -type f -name '*.tgz' -print -quit)"
+          test -n "$PACK_FILE"
+          test -s "$PACK_FILE"
+          tar -tzf "$PACK_FILE" | grep -qx 'package/checksums.txt'
+          echo "filename=$PACK_FILE" >> "$GITHUB_OUTPUT"
+
+      - name: Stage npm package
+        run: npm stage publish "${{ steps.asset.outputs.filename }}" --access public --tag beta

.github/workflows/semantic-review.yml

@@ -25,16 +25,19 @@ jobs:
         with:
           script: |
             const run = context.payload.workflow_run;
-            const workflowId = Number(run.workflow_id || 0);
-            if (!Number.isInteger(workflowId) || workflowId <= 0) throw new Error("missing workflow id");
-            const { data: workflow } = await github.rest.actions.getWorkflow({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              workflow_id: workflowId,
-            });
-            if (workflow.name !== "CI") throw new Error(`unexpected workflow name: ${workflow.name}`);
-            if (workflow.path !== ".github/workflows/ci.yml") throw new Error(`unexpected workflow path: ${workflow.path}`);
-            if (run.path && run.path !== workflow.path) throw new Error(`workflow path mismatch: ${run.path}`);
+            if (run.name !== "CI") throw new Error(`unexpected workflow name: ${run.name}`);
+            let workflowPath = run.path || "";
+            if (!workflowPath) {
+              const workflowId = Number(run.workflow_id || 0);
+              if (!Number.isInteger(workflowId) || workflowId <= 0) throw new Error("missing workflow id");
+              const { data: workflow } = await github.rest.actions.getWorkflow({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                workflow_id: workflowId,
+              });
+              workflowPath = workflow.path || "";
+            }
+            if (workflowPath !== ".github/workflows/ci.yml") throw new Error(`unexpected workflow path: ${workflowPath}`);
             if (run.event !== "pull_request") throw new Error(`unexpected event: ${run.event}`);
             if (run.repository.id !== context.payload.repository.id) throw new Error("repository id mismatch");
             if (run.repository.full_name !== context.payload.repository.full_name) throw new Error("repository name mismatch");
@@ -250,16 +253,19 @@ jobs:
         with:
           script: |
             const run = context.payload.workflow_run;
-            const workflowId = Number(run.workflow_id || 0);
-            if (!Number.isInteger(workflowId) || workflowId <= 0) throw new Error("missing workflow id");
-            const { data: workflow } = await github.rest.actions.getWorkflow({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              workflow_id: workflowId,
-            });
-            if (workflow.name !== "CI") throw new Error(`unexpected workflow name: ${workflow.name}`);
-            if (workflow.path !== ".github/workflows/ci.yml") throw new Error(`unexpected workflow path: ${workflow.path}`);
-            if (run.path && run.path !== workflow.path) throw new Error(`workflow path mismatch: ${run.path}`);
+            if (run.name !== "CI") throw new Error(`unexpected workflow name: ${run.name}`);
+            let workflowPath = run.path || "";
+            if (!workflowPath) {
+              const workflowId = Number(run.workflow_id || 0);
+              if (!Number.isInteger(workflowId) || workflowId <= 0) throw new Error("missing workflow id");
+              const { data: workflow } = await github.rest.actions.getWorkflow({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                workflow_id: workflowId,
+              });
+              workflowPath = workflow.path || "";
+            }
+            if (workflowPath !== ".github/workflows/ci.yml") throw new Error(`unexpected workflow path: ${workflowPath}`);
             if (run.event !== "pull_request") throw new Error(`unexpected event: ${run.event}`);
             if (run.conclusion !== "success") throw new Error(`unexpected conclusion: ${run.conclusion}`);
             if (run.repository.id !== context.payload.repository.id) throw new Error("repository id mismatch");

.goreleaser.yml

@@ -5,8 +5,7 @@ before:
     - python3 scripts/fetch_meta.py
 
 builds:
-  - id: lark-cli
-    binary: lark-cli
+  - binary: lark-cli
     env:
       - CGO_ENABLED=0
     ldflags:
@@ -20,27 +19,11 @@ builds:
       - arm64
       - riscv64
 
-notarize:
-  macos:
-    - enabled: '{{ isEnvSet "MACOS_SIGN_P12" }}'
-      ids:
-        - lark-cli
-      sign:
-        certificate: "{{ .Env.MACOS_SIGN_P12 }}"
-        password: "{{ .Env.MACOS_SIGN_PASSWORD }}"
-      notarize:
-        issuer_id: "{{ .Env.MACOS_NOTARY_ISSUER_ID }}"
-        key_id: "{{ .Env.MACOS_NOTARY_KEY_ID }}"
-        key: "{{ .Env.MACOS_NOTARY_KEY_PATH }}"
-        wait: true
-        timeout: 20m
-
 archives:
   - name_template: "lark-cli-{{ .Version }}-{{ .Os }}-{{ .Arch }}"
-    formats: [tar.gz]
     format_overrides:
       - goos: windows
-        formats: [zip]
+        format: zip
     files:
       - README.md
       - LICENSE

AGENTS.md

@@ -10,10 +10,9 @@
 ## Build & Test
 
 ```bash
-make build             # Build (runs fetch_meta first)
-make unit-test         # Required before PR (runs with -race where supported, e.g. amd64/arm64)
-make live-skills-test  # Opt-in real Skills CLI tests; runs with isolated user directories
-make test              # Full: vet + unit + integration
+make build          # Build (runs fetch_meta first)
+make unit-test      # Required before PR (runs with -race where supported, e.g. amd64/arm64)
+make test           # Full: vet + unit + integration
 ```
 
 ## Notification Opt-Outs

CHANGELOG.md

@@ -2,139 +2,6 @@
 
 All notable changes to this project will be documented in this file.
 
-## [v1.0.78] - 2026-07-27
-
-### Features
-
-- event description support rich text (#1975)
-
-### Bug Fixes
-
-- **slides**: restrict canvas overflow checks
-- **slides**: upgrade text overflow to error above 10px threshold
-- **slides**: detect letterSpacing-driven text overflow
-- **slides**: downgrade background-decoration text overflow to info
-- **slides**: allow chartParsedValues roundtrip tag
-- refine character width estimation for lark-slides text lint
-- **slides**: preserve info lint severity
-- **slides**: text may over flow shape
-- exempt ghost text from slides lint
-
-## [v1.0.77] - 2026-07-24
-
-### Features
-
-- introducing official card icon (#1973)
-- **apps**: validate +file-list --page-size against server (0, 200] range (#2007)
-- **apps**: support absolute and relative upload paths (#2005)
-- **slides**: fill xml-schema-quick-ref gaps that forced XSD fallback (#2026)
-- **slides**: add layout density lint for sparse/empty containers (#2022)
-- add risk-control protection (#1910)
-
-### Bug Fixes
-
-- **slides**: normalize presentation flag aliases (#2032)
-- **base**: classify +form-submit as high-risk-write (#1969)
-- **slides**: declare screenshot scope
-- **slides**: support CSV multi-value for --slide-id in screenshot (#2047)
-
-### Documentation
-
-- **skill**: clarify scope handling for query expansion (#2030)
-- **base**: clarify complete and partial updates (#1993)
-- **skills**: clarify callout child rules (#2048)
-
-### Misc
-
-- fix/task id handling (#2023)
-- fix/task search pagination (#2041)
-
-## [v1.0.75] - 2026-07-22
-
-### Features
-
-- add okr single create shortcut & skill text opti (#1941)
-- **calendar**: auto-add bot self as attendee and note user-only search (#1991)
-
-### Bug Fixes
-
-- **base**: improve table shortcut behavior & guidance (#1803)
-- issue#1935 & whiteboard shortcut reformat (#1980)
-- remove legacy shortcut (#1997)
-- **e2e**: inject shared credentials by identity (#1995)
-
-### Documentation
-
-- **skill**: describe html5 block xml usage (#1380)
-- clarify fetch metadata and user cites (#1981)
-- add topic move collector workflow (#1473)
-- update lark doc HTML size limit (#2001)
-- **base**: align record write schema guidance (#2000)
-
-### Tests
-
-- **e2e**: declare request identities explicitly (#2004)
-
-### Misc
-
-- harden npm release publishing (#1918)
-
-## [v1.0.74] - 2026-07-21
-
-### Features
-
-- **slides**: add history rollback shortcuts (#1714)
-- **base**: support per-record batch updates (#1889)
-
-### Bug Fixes
-
-- preserve slides schema issues
-- allow jq examples in quality gate dry-runs
-- **im**: warn when flag pagination is truncated (#1906)
-- **slides**: warn on text shape overflow
-- **slides**: exempt chart roundtrip attributes from lint
-- **slides**: detect image text occlusion
-- **slides**: clarify xml-text-overlap-lint error for positional argument (#1986)
-
-### Documentation
-
-- clarify drive upload overwrite guidance (#1982)
-
-### Tests
-
-- isolate unit tests from user state (#1883)
-
-### Refactoring
-
-- converge success output through a single Emitter that owns the write (#1899)
-
-## [v1.0.73] - 2026-07-20
-
-### Features
-
-- **apps**: design_html support, creative-design skill, unified TOS publish (#1901)
-
-### Bug Fixes
-
-- **slides**: detect visual elements outside canvas
-- reduce public content credential fixture false positives
-- standardize CLI shortcut text in English (#1942)
-
-### Documentation
-
-- **base**: reduce filter and update retry loops (#1879)
-- **vc**: default transcript routing to smart notes over minutes (#1961)
-- clarify local trigger automation (#1958)
-
-### Tests
-
-- synchronize temporary Git maintenance (#1946)
-
-### Misc
-
-- **slides**: update lark-slides skill to 0715 snapshot (#1933)
-- [codex] support bot menu events (#1765)
-
 ## [v1.0.72] - 2026-07-17
 
 ### Features
@@ -1685,11 +1552,6 @@ Bundled AI agent skills for intelligent assistance:
 - Bilingual documentation (English & Chinese).
 - CI/CD pipelines: linting, testing, coverage reporting, and automated releases.
 
-[v1.0.78]: https://github.com/larksuite/cli/releases/tag/v1.0.78
-[v1.0.77]: https://github.com/larksuite/cli/releases/tag/v1.0.77
-[v1.0.75]: https://github.com/larksuite/cli/releases/tag/v1.0.75
-[v1.0.74]: https://github.com/larksuite/cli/releases/tag/v1.0.74
-[v1.0.73]: https://github.com/larksuite/cli/releases/tag/v1.0.73
 [v1.0.72]: https://github.com/larksuite/cli/releases/tag/v1.0.72
 [v1.0.71]: https://github.com/larksuite/cli/releases/tag/v1.0.71
 [v1.0.70]: https://github.com/larksuite/cli/releases/tag/v1.0.70

Makefile

@@ -23,7 +23,7 @@ PREFIX   ?= /usr/local
 TEST_GOARCH := $(or $(GOARCH),$(shell go env GOARCH))
 RACE_FLAG := $(if $(filter riscv64,$(TEST_GOARCH)),,-race)
 
-.PHONY: all build vet fmt-check script-test test unit-test live-skills-test integration-test examples-build quality-gate install uninstall clean fetch_meta gitleaks sidecar-test
+.PHONY: all build vet fmt-check script-test test unit-test integration-test examples-build quality-gate install uninstall clean fetch_meta gitleaks sidecar-test
 
 all: test
 
@@ -50,20 +50,14 @@ fmt-check:
 script-test:
 	bash scripts/resolve-changed-from.test.sh
 	bash scripts/ci-workflow.test.sh
-	bash scripts/release-workflow.test.sh
 	bash scripts/semantic-review-workflow.test.sh
-	$(NODE) --test scripts/e2e_domains.test.js scripts/fetch_e2e_tat.test.js scripts/install.test.js scripts/release-preflight.test.js scripts/semantic-review-verify-artifact.test.js scripts/pr-quality-summary.test.js scripts/semantic-review-publish.test.js scripts/ci-quality-summary-publish.test.js
+	$(NODE) --test scripts/e2e_domains.test.js scripts/fetch_e2e_tat.test.js scripts/install.test.js scripts/release-preflight.test.js scripts/release-workflow.test.js scripts/semantic-review-verify-artifact.test.js scripts/pr-quality-summary.test.js scripts/semantic-review-publish.test.js scripts/ci-quality-summary-publish.test.js
 
 # ./extension/... keeps the public plugin SDK in the default test matrix.
 unit-test: fetch_meta
 	go test $(RACE_FLAG) -gcflags="all=-N -l" -count=1 \
 		./cmd/... ./internal/... ./shortcuts/... ./extension/...
 
-live-skills-test: fetch_meta
-	LARKSUITE_CLI_RUN_LIVE_SKILLS_TESTS=1 \
-	go test -v -count=1 ./cmd/update \
-		-run '^TestUpdateCommand_(RealSkillsSyncRewritesState|SkillsSyncColdStart)$$'
-
 # examples-build keeps the shipped plugin-SDK examples compilable. If this
 # breaks, the plugin author guide's "go build ./..." path is broken.
 examples-build:

README.md

@@ -285,29 +285,6 @@ To reduce these risks, the tool enables default security protections at multiple
 
 We recommend using the Lark/Feishu bot integrated with this tool as a private conversational assistant. Do not add it to group chats or allow other users to interact with it, to avoid abuse of permissions or data leakage.
 
-To reduce the security risks associated with access token theft, the CLI sends a minimal set of risk-control signals with OpenAPI requests made to exact official Feishu/Lark HTTPS domains. These signals are used to help identify anomalous API activity. This protection is enabled by default. The information sent is limited to:
-
-- Operating system type: macOS, Windows, or Linux
-- Device hardware model: for example, Mac17,9
-
-To disable this protection for the current workspace, run:
-
-```bash
-lark-cli config risk-control off
-```
-
-To enable this protection for the current workspace, run:
-
-```bash
-lark-cli config risk-control on
-```
-
-To restore the default policy for the current workspace, run:
-
-```bash
-lark-cli config risk-control default
-```
-
 Please fully understand all usage risks. By using this tool, you are deemed to voluntarily assume all related responsibilities.
 
 ## Star History

README.zh.md

@@ -286,29 +286,6 @@ lark-cli schema im.messages.delete
 
 我们建议您将对接本工具的飞书机器人作为私人对话助手使用，请勿将其拉入群聊或允许其他用户与其交互，以避免权限被滥用或数据泄露。
 
-为降低访问令牌被盗用后的安全风险，CLI 在向飞书/Lark 官方 HTTPS 精确域名发起 OpenAPI 请求时，会随请求发送一组最小化的风控信号，用于辅助识别异常调用行为。该保护默认开启，发送的信息仅包括：
-
-- 操作系统类型：macOS、Windows 或 Linux
-- 设备的硬件产品型号：例如 Mac17,9
-
-如需让当前 workspace 退出该保护，可执行以下命令：
-
-```bash
-lark-cli config risk-control off
-```
-
-如需开启当前 workspace 的保护，可执行以下命令：
-
-```bash
-lark-cli config risk-control on
-```
-
-恢复当前 workspace 默认策略可执行：
-
-```bash
-lark-cli config risk-control default
-```
-
 请您充分知悉全部使用风险，使用本工具即视为您自愿承担相关所有责任。
 
 ## Star History

cmd/api/api.go

@@ -344,18 +344,20 @@ func apiPaginate(ctx context.Context, ac *client.APIClient, request client.RawAp
 
 	switch format {
 	case output.FormatNDJSON, output.FormatTable, output.FormatCSV:
-		emitter := output.NewEmitter(output.EmitterConfig{
-			Out:            out,
-			ErrOut:         errOut,
-			CommandPath:    commandPath,
-			Identity:       string(pagOpts.Identity),
-			NoticeProvider: output.GetNotice,
-		})
+		pf := output.NewPaginatedFormatter(out, format)
 		result, hasItems, err := ac.StreamPages(ctx, request, func(items []interface{}) error {
 			// Streaming formats intentionally emit each page after that page has
 			// passed safety scanning. A later page may still fail, so callers
 			// must use the exit code to distinguish complete vs partial output.
-			return emitter.StreamPage(items, output.StreamOptions{Format: format.String()})
+			scanResult := output.ScanForSafety(commandPath, items, errOut)
+			if scanResult.Blocked {
+				return scanResult.BlockErr
+			}
+			if scanResult.Alert != nil {
+				output.WriteAlertWarning(errOut, scanResult.Alert)
+			}
+			pf.FormatPage(items)
+			return nil
 		}, pagOpts)
 		if err != nil {
 			return errs.MarkRaw(err)

cmd/api/api_paginate_test.go

@@ -1,396 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package api
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/client"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/httpmock"
-	"github.com/larksuite/cli/internal/output"
-)
-
-type apiFailOnWriteWriter struct {
-	buf    bytes.Buffer
-	writes int
-	failAt int
-	err    error
-}
-
-func (w *apiFailOnWriteWriter) Write(p []byte) (int, error) {
-	w.writes++
-	if w.writes == w.failAt {
-		return 0, w.err
-	}
-	return w.buf.Write(p)
-}
-
-func newAPIPaginateTestHarness(t *testing.T) (*client.APIClient, *bytes.Buffer, *bytes.Buffer, *httpmock.Registry) {
-	t.Helper()
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-	previousNotice := output.PendingNotice
-	output.PendingNotice = nil
-	t.Cleanup(func() { output.PendingNotice = previousNotice })
-
-	config := &core.CliConfig{
-		AppID:     "test-app",
-		AppSecret: "test-secret",
-		Brand:     core.BrandFeishu,
-	}
-	f, out, errOut, reg := cmdutil.TestFactory(t, config)
-	ac, err := f.NewAPIClientWithConfig(config)
-	if err != nil {
-		t.Fatalf("NewAPIClientWithConfig() error = %v", err)
-	}
-	ac.ErrOut = io.Discard
-	return ac, out, errOut, reg
-}
-
-func apiPaginateRequest() client.RawApiRequest {
-	return client.RawApiRequest{
-		Method: "GET",
-		URL:    "/open-apis/test/v1/items",
-		As:     core.AsBot,
-	}
-}
-
-func assertAPIPaginateJSONBytes(t *testing.T, got []byte, want interface{}) {
-	t.Helper()
-	wantBytes, err := json.MarshalIndent(want, "", "  ")
-	if err != nil {
-		t.Fatalf("marshal expected JSON: %v", err)
-	}
-	wantBytes = append(wantBytes, '\n')
-	if !bytes.Equal(got, wantBytes) {
-		t.Fatalf("stdout bytes mismatch\ngot:\n%s\nwant:\n%s", got, wantBytes)
-	}
-}
-
-func TestAPIPaginate_DefaultAggregatesAllPages(t *testing.T) {
-	ac, out, errOut, reg := newAPIPaginateTestHarness(t)
-	calls := 0
-	wantTokens := []string{"", "next-1", "next-2"}
-	for i, wantToken := range wantTokens {
-		page := i + 1
-		hasMore := page < len(wantTokens)
-		data := map[string]interface{}{
-			"items":    []interface{}{map[string]interface{}{"id": string(rune('0' + page))}},
-			"has_more": hasMore,
-		}
-		if hasMore {
-			data["page_token"] = wantTokens[page]
-		}
-		reg.Register(&httpmock.Stub{
-			URL: "/open-apis/test/v1/items",
-			OnMatch: func(req *http.Request) {
-				calls++
-				if got := req.URL.Query().Get("page_token"); got != wantToken {
-					t.Errorf("request %d page_token = %q, want %q", page, got, wantToken)
-				}
-			},
-			Body: map[string]interface{}{
-				"code": 0,
-				"msg":  "ok",
-				"data": data,
-			},
-		})
-	}
-
-	err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
-		output.FormatJSON, "", out, errOut, "lark-cli api GET", client.PaginationOptions{
-			PageLimit: 10,
-			PageDelay: -1,
-		})
-
-	if err != nil {
-		t.Fatalf("apiPaginate() error = %v, want nil", err)
-	}
-	if calls != 3 {
-		t.Fatalf("pagination requests = %d, want 3", calls)
-	}
-	assertAPIPaginateJSONBytes(t, out.Bytes(), output.Envelope{
-		OK:       true,
-		Identity: "bot",
-		Data: map[string]interface{}{
-			"items": []interface{}{
-				map[string]interface{}{"id": "1"},
-				map[string]interface{}{"id": "2"},
-				map[string]interface{}{"id": "3"},
-			},
-			"has_more": false,
-		},
-	})
-	if got := errOut.String(); got != "" {
-		t.Fatalf("stderr bytes = %q, want empty", got)
-	}
-}
-
-func TestAPIPaginate_StreamingFormatsEmitExactMultiPageBytes(t *testing.T) {
-	tests := []struct {
-		name   string
-		format output.Format
-		want   string
-	}{
-		{
-			name:   "ndjson",
-			format: output.FormatNDJSON,
-			want:   "{\"id\":\"1\",\"name\":\"Alice\"}\n{\"id\":\"2\",\"name\":\"Carol\",\"page_only\":\"ignored\"}\n",
-		},
-		{
-			name:   "table",
-			format: output.FormatTable,
-			want:   "id  name \n──  ─────\n1   Alice\n2   Carol\n",
-		},
-		{
-			name:   "csv",
-			format: output.FormatCSV,
-			want:   "id,name\n1,Alice\n2,Carol\n",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ac, out, errOut, reg := newAPIPaginateTestHarness(t)
-			reg.Register(&httpmock.Stub{
-				URL: "/open-apis/test/v1/items",
-				Body: map[string]interface{}{
-					"code": 0,
-					"msg":  "ok",
-					"data": map[string]interface{}{
-						"items": []interface{}{
-							map[string]interface{}{"id": "1", "name": "Alice"},
-						},
-						"has_more":   true,
-						"page_token": "next-1",
-					},
-				},
-			})
-			reg.Register(&httpmock.Stub{
-				URL: "/open-apis/test/v1/items",
-				Body: map[string]interface{}{
-					"code": 0,
-					"msg":  "ok",
-					"data": map[string]interface{}{
-						"items": []interface{}{
-							map[string]interface{}{"id": "2", "name": "Carol", "page_only": "ignored"},
-						},
-						"has_more": false,
-					},
-				},
-			})
-
-			err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
-				tt.format, "", out, errOut, "lark-cli api GET", client.PaginationOptions{
-					PageLimit: 10,
-					PageDelay: -1,
-				})
-
-			if err != nil {
-				t.Fatalf("apiPaginate() error = %v, want nil", err)
-			}
-			if got := out.String(); got != tt.want {
-				t.Fatalf("stdout byte mismatch\ngot (%d bytes):\n%q\nwant (%d bytes):\n%q", len(got), got, len(tt.want), tt.want)
-			}
-			if got := errOut.String(); got != "" {
-				t.Fatalf("stderr bytes = %q, want empty", got)
-			}
-		})
-	}
-}
-
-func TestAPIPaginate_StreamingWriteFailureStopsFurtherPages(t *testing.T) {
-	ac, _, errOut, reg := newAPIPaginateTestHarness(t)
-	sentinel := errors.New("page write failed")
-	out := &apiFailOnWriteWriter{failAt: 2, err: sentinel}
-	calls := 0
-	for page := 1; page <= 2; page++ {
-		hasMore := true
-		data := map[string]interface{}{
-			"items":    []interface{}{map[string]interface{}{"id": page}},
-			"has_more": hasMore,
-		}
-		if hasMore {
-			data["page_token"] = fmt.Sprintf("next-%d", page)
-		}
-		reg.Register(&httpmock.Stub{
-			URL: "/open-apis/test/v1/items",
-			OnMatch: func(*http.Request) {
-				calls++
-			},
-			Body: map[string]interface{}{
-				"code": 0,
-				"msg":  "ok",
-				"data": data,
-			},
-		})
-	}
-
-	err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
-		output.FormatNDJSON, "", out, errOut, "lark-cli api GET",
-		client.PaginationOptions{PageLimit: 10, PageDelay: -1})
-
-	if !errors.Is(err, sentinel) {
-		t.Fatalf("apiPaginate() error = %v, want preserved writer cause", err)
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok || problem.Category != errs.CategoryInternal {
-		t.Fatalf("apiPaginate() problem = %#v, %v; want internal typed error", problem, ok)
-	}
-	if calls != 2 {
-		t.Fatalf("pagination requests = %d, want 2", calls)
-	}
-	if got, want := out.buf.String(), "{\"id\":1}\n"; got != want {
-		t.Fatalf("stdout bytes = %q, want %q", got, want)
-	}
-}
-
-func TestAPIPaginate_StreamingFormatFallsBackToJSONWithoutList(t *testing.T) {
-	ac, out, errOut, reg := newAPIPaginateTestHarness(t)
-	reg.Register(&httpmock.Stub{
-		URL: "/open-apis/test/v1/items",
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "ok",
-			"data": map[string]interface{}{
-				"name":    "Test User",
-				"user_id": "u123",
-			},
-		},
-	})
-
-	err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
-		output.FormatNDJSON, "", out, errOut, "lark-cli api GET", client.PaginationOptions{PageDelay: -1})
-
-	if err != nil {
-		t.Fatalf("apiPaginate() error = %v, want nil", err)
-	}
-	assertAPIPaginateJSONBytes(t, out.Bytes(), output.Envelope{
-		OK:       true,
-		Identity: "bot",
-		Data: map[string]interface{}{
-			"name":    "Test User",
-			"user_id": "u123",
-		},
-	})
-	wantWarning := "warning: this API does not return a list, format \"ndjson\" is not supported, falling back to json\n"
-	if got := errOut.String(); got != wantWarning {
-		t.Fatalf("stderr bytes = %q, want %q", got, wantWarning)
-	}
-}
-
-func TestAPIPaginate_BusinessErrorsWriteRawAndAreMarkedRaw(t *testing.T) {
-	businessResponse := map[string]interface{}{
-		"code": 123456,
-		"msg":  "fixture business error",
-		"data": map[string]interface{}{"detail": "business failed"},
-	}
-	tests := []struct {
-		name   string
-		format output.Format
-		jqExpr string
-	}{
-		{name: "jq", format: output.FormatJSON, jqExpr: ".data.items"},
-		{name: "default_json", format: output.FormatJSON},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ac, out, errOut, reg := newAPIPaginateTestHarness(t)
-			reg.Register(&httpmock.Stub{
-				URL:  "/open-apis/test/v1/items",
-				Body: businessResponse,
-			})
-
-			err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
-				tt.format, tt.jqExpr, out, errOut, "lark-cli api GET", client.PaginationOptions{PageDelay: -1})
-
-			if err == nil {
-				t.Fatal("apiPaginate() error = nil, want business error")
-			}
-			if !errs.IsRaw(err) {
-				t.Fatalf("errs.IsRaw(error) = false, want true; error = %T: %v", err, err)
-			}
-			assertAPIPaginateJSONBytes(t, out.Bytes(), businessResponse)
-			if bytes.Contains(out.Bytes(), []byte(`"ok": true`)) {
-				t.Fatalf("business-error stdout contains a success envelope:\n%s", out.Bytes())
-			}
-			if got := errOut.String(); got != "" {
-				t.Fatalf("stderr bytes = %q, want empty", got)
-			}
-		})
-	}
-}
-
-func TestAPIPaginate_TransportErrorsAreMarkedRaw(t *testing.T) {
-	tests := []struct {
-		name   string
-		format output.Format
-		jqExpr string
-	}{
-		{name: "jq_paginate_all", format: output.FormatJSON, jqExpr: ".data.items"},
-		{name: "stream_pages", format: output.FormatNDJSON},
-		{name: "default_paginate_all", format: output.FormatJSON},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ac, out, errOut, _ := newAPIPaginateTestHarness(t)
-
-			err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
-				tt.format, tt.jqExpr, out, errOut, "lark-cli api GET", client.PaginationOptions{PageDelay: -1})
-
-			if err == nil {
-				t.Fatal("apiPaginate() error = nil, want transport error")
-			}
-			if !errs.IsRaw(err) {
-				t.Fatalf("errs.IsRaw(error) = false, want true; error = %T: %v", err, err)
-			}
-			if got := out.String(); got != "" {
-				t.Fatalf("stdout bytes = %q, want empty", got)
-			}
-			if got := errOut.String(); got != "" {
-				t.Fatalf("stderr bytes = %q, want empty", got)
-			}
-		})
-	}
-}
-
-func TestAPIPaginate_StreamBusinessErrorIsMarkedRaw(t *testing.T) {
-	ac, out, errOut, reg := newAPIPaginateTestHarness(t)
-	reg.Register(&httpmock.Stub{
-		URL: "/open-apis/test/v1/items",
-		Body: map[string]interface{}{
-			"code": 123456,
-			"msg":  "fixture business error",
-			"data": map[string]interface{}{},
-		},
-	})
-
-	err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
-		output.FormatNDJSON, "", out, errOut, "lark-cli api GET", client.PaginationOptions{PageDelay: -1})
-
-	if err == nil {
-		t.Fatal("apiPaginate() error = nil, want business error")
-	}
-	if !errs.IsRaw(err) {
-		t.Fatalf("errs.IsRaw(error) = false, want true; error = %T: %v", err, err)
-	}
-	if got := out.String(); got != "" {
-		t.Fatalf("stdout bytes = %q, want empty", got)
-	}
-	if got := errOut.String(); got != "" {
-		t.Fatalf("stderr bytes = %q, want empty", got)
-	}
-}

cmd/api/api_test.go

@@ -352,9 +352,6 @@ func TestApiCmd_OutputAndPageAllConflict(t *testing.T) {
 }
 
 func TestApiCmd_BinaryResponse_AutoSave(t *testing.T) {
-	dir := t.TempDir()
-	cmdutil.TestChdir(t, dir)
-
 	f, stdout, stderr, reg := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app-bin", AppSecret: "test-secret-bin", Brand: core.BrandFeishu,
 	})
@@ -374,33 +371,8 @@ func TestApiCmd_BinaryResponse_AutoSave(t *testing.T) {
 	if !strings.Contains(stderr.String(), "binary response detected") {
 		t.Error("expected binary response hint in stderr")
 	}
-	var got map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
-		t.Fatalf("stdout is not JSON: %v\nstdout:\n%s", err, stdout.String())
-	}
-	savedPath, _ := got["saved_path"].(string)
-	if savedPath == "" {
-		t.Fatalf("saved_path missing from output: %#v", got)
-	}
-	// The file must land inside the temporary cwd — this pins the isolation
-	// contract: rolling back TestChdir would leave download.bin in the repo.
-	wantDir, err := filepath.EvalSymlinks(dir)
-	if err != nil {
-		t.Fatal(err)
-	}
-	gotDir, err := filepath.EvalSymlinks(filepath.Dir(savedPath))
-	if err != nil {
-		t.Fatalf("saved_path %q dir not resolvable: %v", savedPath, err)
-	}
-	if gotDir != wantDir {
-		t.Errorf("saved_path %q is outside temp cwd %q", savedPath, wantDir)
-	}
-	content, err := os.ReadFile(savedPath)
-	if err != nil {
-		t.Fatalf("read saved file: %v", err)
-	}
-	if string(content) != "fake-binary-content" {
-		t.Errorf("saved file content = %q, want %q", content, "fake-binary-content")
+	if !strings.Contains(stdout.String(), "saved_path") {
+		t.Error("expected saved_path in output")
 	}
 }
 

cmd/auth/testmain_test.go

@@ -1,46 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package auth
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/larksuite/cli/internal/registry/registrytest"
-)
-
-// TestMain isolates auth command tests from the host machine: config, logs
-// and the registry cache are redirected to a temp dir, then the registry is
-// seeded from the tracked fixture and initialized eagerly. Domain-completion
-// tests read the registry, so without seeding a clean checkout would either
-// fail or trigger a remote metadata fetch.
-//
-// Note: os.Exit skips deferred functions, so cleanup runs explicitly after
-// m.Run before exiting.
-func TestMain(m *testing.M) {
-	root, err := os.MkdirTemp("", "lark-cli-cmd-auth-test-*")
-	if err != nil {
-		println("cmd/auth test setup: MkdirTemp failed:", err.Error())
-		os.Exit(2)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", filepath.Join(root, "config")); err != nil {
-		println("cmd/auth test setup: Setenv failed:", err.Error())
-		os.RemoveAll(root)
-		os.Exit(2)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_LOG_DIR", filepath.Join(root, "logs")); err != nil {
-		println("cmd/auth test setup: Setenv failed:", err.Error())
-		os.RemoveAll(root)
-		os.Exit(2)
-	}
-	if err := registrytest.Seed(root); err != nil {
-		println("cmd/auth test setup: registrytest.Seed failed:", err.Error())
-		os.RemoveAll(root)
-		os.Exit(2)
-	}
-	code := m.Run()
-	_ = os.RemoveAll(root)
-	os.Exit(code)
-}

cmd/config/config.go

@@ -31,7 +31,6 @@ func NewCmdConfig(f *cmdutil.Factory) *cobra.Command {
 	cmd.AddCommand(NewCmdConfigShow(f, nil))
 	cmd.AddCommand(NewCmdConfigDefaultAs(f))
 	cmd.AddCommand(NewCmdConfigStrictMode(f))
-	cmd.AddCommand(NewCmdConfigRiskControl(f))
 	cmd.AddCommand(NewCmdConfigPolicy(f))
 	cmd.AddCommand(NewCmdConfigPlugins(f))
 	cmd.AddCommand(NewCmdConfigKeychainDowngrade(f))

cmd/config/risk_control.go

@@ -1,80 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package config
-
-import (
-	"fmt"
-
-	"github.com/spf13/cobra"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-)
-
-// NewCmdConfigRiskControl creates the workspace risk-control policy command.
-func NewCmdConfigRiskControl(f *cmdutil.Factory) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "risk-control [on|off|default]",
-		Short: "Manage workspace account-protection policy",
-		Long: `View or set the account-protection risk-control policy for this workspace.
-
-Account protection is on by default. Use off to opt this workspace out, on to
-opt it back in explicitly, or default to remove the explicit preference.`,
-		Args: cobra.MaximumNArgs(1),
-		// This is persistent workspace policy, not credential management.
-		PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
-			cmd.SilenceUsage = true
-			return nil
-		},
-		RunE: func(cmd *cobra.Command, args []string) error {
-			config, err := core.LoadOrNotConfigured()
-			if err != nil {
-				return err
-			}
-			if len(args) == 0 {
-				printRiskControl(f, config)
-				return nil
-			}
-
-			switch args[0] {
-			case "on":
-				enabled := true
-				config.RiskControl = &enabled
-			case "off":
-				enabled := false
-				config.RiskControl = &enabled
-			case "default":
-				config.RiskControl = nil
-			default:
-				return errs.NewValidationError(errs.SubtypeInvalidArgument,
-					"invalid risk-control value %q, valid values: on | off | default", args[0])
-			}
-
-			if err := core.SaveMultiAppConfig(config); err != nil {
-				return errs.NewInternalError(errs.SubtypeStorage,
-					"failed to save risk-control policy: %v", err).WithCause(err)
-			}
-			fmt.Fprintf(f.IOStreams.ErrOut, "Risk control set to %s (workspace)\n", args[0])
-			return nil
-		},
-	}
-	cmdutil.SetRisk(cmd, cmdutil.RiskWrite)
-	return cmd
-}
-
-func printRiskControl(f *cmdutil.Factory, config *core.MultiAppConfig) {
-	source := "default"
-	if config.RiskControl != nil {
-		source = "workspace"
-	}
-	fmt.Fprintf(f.IOStreams.Out, "risk-control: %s (source: %s)\n", riskControlState(config.RiskControlEnabled()), source)
-}
-
-func riskControlState(enabled bool) string {
-	if enabled {
-		return "on"
-	}
-	return "off"
-}

cmd/config/risk_control_test.go

@@ -1,130 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package config
-
-import (
-	"errors"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-)
-
-func TestRiskControlWorkspacePolicy(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	config := &core.MultiAppConfig{Apps: []core.AppConfig{{
-		AppId: "cli_test", AppSecret: core.PlainSecret("secret"), Brand: core.BrandFeishu,
-	}}}
-	if err := core.SaveMultiAppConfig(config); err != nil {
-		t.Fatal(err)
-	}
-
-	f, stdout, stderr, _ := cmdutil.TestFactory(t, nil)
-	cmd := NewCmdConfigRiskControl(f)
-	cmd.SetArgs([]string{"off"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("set off: %v", err)
-	}
-	loaded, err := core.LoadMultiAppConfig()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if loaded.RiskControl == nil || *loaded.RiskControl {
-		t.Fatalf("RiskControl = %v, want explicit false", loaded.RiskControl)
-	}
-	if !strings.Contains(stderr.String(), "set to off") {
-		t.Fatalf("stderr = %q", stderr.String())
-	}
-
-	stdout.Reset()
-	cmd = NewCmdConfigRiskControl(f)
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("show: %v", err)
-	}
-	if got := stdout.String(); got != "risk-control: off (source: workspace)\n" {
-		t.Fatalf("stdout = %q", got)
-	}
-
-	cmd = NewCmdConfigRiskControl(f)
-	cmd.SetArgs([]string{"on"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("set on: %v", err)
-	}
-	loaded, err = core.LoadMultiAppConfig()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if loaded.RiskControl == nil || !*loaded.RiskControl {
-		t.Fatalf("RiskControl = %v, want explicit true", loaded.RiskControl)
-	}
-
-	cmd = NewCmdConfigRiskControl(f)
-	cmd.SetArgs([]string{"default"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("reset default: %v", err)
-	}
-	loaded, err = core.LoadMultiAppConfig()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if loaded.RiskControl != nil {
-		t.Fatalf("RiskControl = %v, want nil", loaded.RiskControl)
-	}
-
-	stdout.Reset()
-	cmd = NewCmdConfigRiskControl(f)
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("show default: %v", err)
-	}
-	if got := stdout.String(); got != "risk-control: on (source: default)\n" {
-		t.Fatalf("stdout = %q", got)
-	}
-}
-
-func TestRiskControlWorkspacePolicyRejectsInvalidValue(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	if err := core.SaveMultiAppConfig(&core.MultiAppConfig{Apps: []core.AppConfig{{
-		AppId: "cli_test", AppSecret: core.PlainSecret("secret"), Brand: core.BrandFeishu,
-	}}}); err != nil {
-		t.Fatal(err)
-	}
-
-	f, _, _, _ := cmdutil.TestFactory(t, nil)
-	cmd := NewCmdConfigRiskControl(f)
-	cmd.SetArgs([]string{"invalid"})
-	err := cmd.Execute()
-	var validationErr *errs.ValidationError
-	if !errors.As(err, &validationErr) {
-		t.Fatalf("error = %T %v, want *errs.ValidationError", err, err)
-	}
-	if validationErr.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("subtype = %q, want %q", validationErr.Subtype, errs.SubtypeInvalidArgument)
-	}
-}
-
-func TestRiskControlWorkspacePolicyAllowedWithExternalCredentials(t *testing.T) {
-	f := newConfigFactoryWithExternalProvider(t)
-	config := &core.MultiAppConfig{Apps: []core.AppConfig{{
-		AppId: "cli_test", AppSecret: core.PlainSecret("secret"), Brand: core.BrandFeishu,
-	}}}
-	if err := core.SaveMultiAppConfig(config); err != nil {
-		t.Fatal(err)
-	}
-
-	cmd := NewCmdConfig(f)
-	cmd.SetArgs([]string{"risk-control", "off"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("set off with external credentials: %v", err)
-	}
-
-	loaded, err := core.LoadMultiAppConfig()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if loaded.RiskControl == nil || *loaded.RiskControl {
-		t.Fatalf("RiskControl = %v, want explicit false", loaded.RiskControl)
-	}
-}

cmd/root_integration_test.go

@@ -371,11 +371,10 @@ func TestIntegration_StrictModeUser_ProfileOverride_ShortcutExplicitBotReturnsEn
 
 func TestIntegration_StrictModeBot_ProfileOverride_ServiceExplicitUserReturnsEnvelope(t *testing.T) {
 	f, stdout, stderr := newStrictModeDefaultFactory(t, "target", core.StrictModeBot)
-	catalog := strictModeFixtureCatalog()
-	rootCmd := buildStrictModeIntegrationRootCmdWithCatalog(t, f, &catalog)
+	rootCmd := buildStrictModeIntegrationRootCmd(t, f)
 
 	code := executeRootIntegration(t, f, rootCmd, []string{
-		"fixture", "things", "create", "--data", `{"name":"probe"}`, "--as", "user", "--dry-run",
+		"im", "chats", "get", "--params", `{"chat_id":"oc_test"}`, "--as", "user", "--dry-run",
 	})
 
 	if code != output.ExitValidation {

cmd/service/service.go

@@ -707,18 +707,20 @@ func servicePaginate(ctx context.Context, ac *client.APIClient, request client.R
 
 	switch format {
 	case output.FormatNDJSON, output.FormatTable, output.FormatCSV:
-		emitter := output.NewEmitter(output.EmitterConfig{
-			Out:            out,
-			ErrOut:         errOut,
-			CommandPath:    commandPath,
-			Identity:       string(pagOpts.Identity),
-			NoticeProvider: output.GetNotice,
-		})
+		pf := output.NewPaginatedFormatter(out, format)
 		result, hasItems, err := ac.StreamPages(ctx, request, func(items []interface{}) error {
 			// Streaming formats intentionally emit each page after that page has
 			// passed safety scanning. A later page may still fail, so callers
 			// must use the exit code to distinguish complete vs partial output.
-			return emitter.StreamPage(items, output.StreamOptions{Format: format.String()})
+			scanResult := output.ScanForSafety(commandPath, items, errOut)
+			if scanResult.Blocked {
+				return scanResult.BlockErr
+			}
+			if scanResult.Alert != nil {
+				output.WriteAlertWarning(errOut, scanResult.Alert)
+			}
+			pf.FormatPage(items)
+			return nil
 		}, pagOpts)
 		if err != nil {
 			return err

cmd/service/service_paginate_test.go

@@ -1,400 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package service
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/client"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/httpmock"
-	"github.com/larksuite/cli/internal/output"
-)
-
-type serviceFailOnWriteWriter struct {
-	buf    bytes.Buffer
-	writes int
-	failAt int
-	err    error
-}
-
-func (w *serviceFailOnWriteWriter) Write(p []byte) (int, error) {
-	w.writes++
-	if w.writes == w.failAt {
-		return 0, w.err
-	}
-	return w.buf.Write(p)
-}
-
-func newServicePaginateTestHarness(t *testing.T) (*client.APIClient, *bytes.Buffer, *bytes.Buffer, *httpmock.Registry) {
-	t.Helper()
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-	previousNotice := output.PendingNotice
-	output.PendingNotice = nil
-	t.Cleanup(func() { output.PendingNotice = previousNotice })
-
-	config := &core.CliConfig{
-		AppID:     "test-app",
-		AppSecret: "test-secret",
-		Brand:     core.BrandFeishu,
-	}
-	f, out, errOut, reg := cmdutil.TestFactory(t, config)
-	ac, err := f.NewAPIClientWithConfig(config)
-	if err != nil {
-		t.Fatalf("NewAPIClientWithConfig() error = %v", err)
-	}
-	ac.ErrOut = io.Discard
-	return ac, out, errOut, reg
-}
-
-func servicePaginateRequest() client.RawApiRequest {
-	return client.RawApiRequest{
-		Method: "GET",
-		URL:    "/open-apis/test/v1/items",
-		As:     core.AsBot,
-	}
-}
-
-func assertServicePaginateJSONBytes(t *testing.T, got []byte, want interface{}) {
-	t.Helper()
-	wantBytes, err := json.MarshalIndent(want, "", "  ")
-	if err != nil {
-		t.Fatalf("marshal expected JSON: %v", err)
-	}
-	wantBytes = append(wantBytes, '\n')
-	if !bytes.Equal(got, wantBytes) {
-		t.Fatalf("stdout bytes mismatch\ngot:\n%s\nwant:\n%s", got, wantBytes)
-	}
-}
-
-func TestServicePaginate_DefaultAggregatesAllPages(t *testing.T) {
-	ac, out, errOut, reg := newServicePaginateTestHarness(t)
-	calls := 0
-	wantTokens := []string{"", "next-1", "next-2"}
-	for i, wantToken := range wantTokens {
-		page := i + 1
-		hasMore := page < len(wantTokens)
-		data := map[string]interface{}{
-			"items":    []interface{}{map[string]interface{}{"id": string(rune('0' + page))}},
-			"has_more": hasMore,
-		}
-		if hasMore {
-			data["page_token"] = wantTokens[page]
-		}
-		reg.Register(&httpmock.Stub{
-			URL: "/open-apis/test/v1/items",
-			OnMatch: func(req *http.Request) {
-				calls++
-				if got := req.URL.Query().Get("page_token"); got != wantToken {
-					t.Errorf("request %d page_token = %q, want %q", page, got, wantToken)
-				}
-			},
-			Body: map[string]interface{}{
-				"code": 0,
-				"msg":  "ok",
-				"data": data,
-			},
-		})
-	}
-
-	err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
-		output.FormatJSON, "", out, errOut, "lark-cli test items list", client.PaginationOptions{
-			PageLimit: 10,
-			PageDelay: -1,
-		}, ac.CheckResponse)
-
-	if err != nil {
-		t.Fatalf("servicePaginate() error = %v, want nil", err)
-	}
-	if calls != 3 {
-		t.Fatalf("pagination requests = %d, want 3", calls)
-	}
-	assertServicePaginateJSONBytes(t, out.Bytes(), output.Envelope{
-		OK:       true,
-		Identity: "bot",
-		Data: map[string]interface{}{
-			"items": []interface{}{
-				map[string]interface{}{"id": "1"},
-				map[string]interface{}{"id": "2"},
-				map[string]interface{}{"id": "3"},
-			},
-			"has_more": false,
-		},
-	})
-	if got := errOut.String(); got != "" {
-		t.Fatalf("stderr bytes = %q, want empty", got)
-	}
-}
-
-func TestServicePaginate_StreamingFormatsEmitExactMultiPageBytes(t *testing.T) {
-	tests := []struct {
-		name   string
-		format output.Format
-		want   string
-	}{
-		{
-			name:   "ndjson",
-			format: output.FormatNDJSON,
-			want:   "{\"id\":\"1\",\"name\":\"Alice\"}\n{\"id\":\"2\",\"name\":\"Carol\",\"page_only\":\"ignored\"}\n",
-		},
-		{
-			name:   "table",
-			format: output.FormatTable,
-			want:   "id  name \n──  ─────\n1   Alice\n2   Carol\n",
-		},
-		{
-			name:   "csv",
-			format: output.FormatCSV,
-			want:   "id,name\n1,Alice\n2,Carol\n",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ac, out, errOut, reg := newServicePaginateTestHarness(t)
-			reg.Register(&httpmock.Stub{
-				URL: "/open-apis/test/v1/items",
-				Body: map[string]interface{}{
-					"code": 0,
-					"msg":  "ok",
-					"data": map[string]interface{}{
-						"items": []interface{}{
-							map[string]interface{}{"id": "1", "name": "Alice"},
-						},
-						"has_more":   true,
-						"page_token": "next-1",
-					},
-				},
-			})
-			reg.Register(&httpmock.Stub{
-				URL: "/open-apis/test/v1/items",
-				Body: map[string]interface{}{
-					"code": 0,
-					"msg":  "ok",
-					"data": map[string]interface{}{
-						"items": []interface{}{
-							map[string]interface{}{"id": "2", "name": "Carol", "page_only": "ignored"},
-						},
-						"has_more": false,
-					},
-				},
-			})
-
-			err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
-				tt.format, "", out, errOut, "lark-cli test items list", client.PaginationOptions{
-					PageLimit: 10,
-					PageDelay: -1,
-				}, ac.CheckResponse)
-
-			if err != nil {
-				t.Fatalf("servicePaginate() error = %v, want nil", err)
-			}
-			if got := out.String(); got != tt.want {
-				t.Fatalf("stdout byte mismatch\ngot (%d bytes):\n%q\nwant (%d bytes):\n%q", len(got), got, len(tt.want), tt.want)
-			}
-			if got := errOut.String(); got != "" {
-				t.Fatalf("stderr bytes = %q, want empty", got)
-			}
-		})
-	}
-}
-
-func TestServicePaginate_StreamingWriteFailureStopsFurtherPages(t *testing.T) {
-	ac, _, errOut, reg := newServicePaginateTestHarness(t)
-	sentinel := errors.New("page write failed")
-	out := &serviceFailOnWriteWriter{failAt: 2, err: sentinel}
-	calls := 0
-	for page := 1; page <= 2; page++ {
-		hasMore := true
-		data := map[string]interface{}{
-			"items":    []interface{}{map[string]interface{}{"id": page}},
-			"has_more": hasMore,
-		}
-		if hasMore {
-			data["page_token"] = fmt.Sprintf("next-%d", page)
-		}
-		reg.Register(&httpmock.Stub{
-			URL: "/open-apis/test/v1/items",
-			OnMatch: func(*http.Request) {
-				calls++
-			},
-			Body: map[string]interface{}{
-				"code": 0,
-				"msg":  "ok",
-				"data": data,
-			},
-		})
-	}
-
-	err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
-		output.FormatNDJSON, "", out, errOut, "lark-cli test items list",
-		client.PaginationOptions{PageLimit: 10, PageDelay: -1}, ac.CheckResponse)
-
-	if !errors.Is(err, sentinel) {
-		t.Fatalf("servicePaginate() error = %v, want preserved writer cause", err)
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok || problem.Category != errs.CategoryInternal {
-		t.Fatalf("servicePaginate() problem = %#v, %v; want internal typed error", problem, ok)
-	}
-	if calls != 2 {
-		t.Fatalf("pagination requests = %d, want 2", calls)
-	}
-	if got, want := out.buf.String(), "{\"id\":1}\n"; got != want {
-		t.Fatalf("stdout bytes = %q, want %q", got, want)
-	}
-}
-
-func TestServicePaginate_StreamingFormatFallsBackToJSONWithoutList(t *testing.T) {
-	ac, out, errOut, reg := newServicePaginateTestHarness(t)
-	reg.Register(&httpmock.Stub{
-		URL: "/open-apis/test/v1/items",
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "ok",
-			"data": map[string]interface{}{
-				"name":    "Test User",
-				"user_id": "u123",
-			},
-		},
-	})
-
-	err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
-		output.FormatNDJSON, "", out, errOut, "lark-cli test items get",
-		client.PaginationOptions{PageDelay: -1}, ac.CheckResponse)
-
-	if err != nil {
-		t.Fatalf("servicePaginate() error = %v, want nil", err)
-	}
-	assertServicePaginateJSONBytes(t, out.Bytes(), output.Envelope{
-		OK:       true,
-		Identity: "bot",
-		Data: map[string]interface{}{
-			"name":    "Test User",
-			"user_id": "u123",
-		},
-	})
-	wantWarning := "warning: this API does not return a list, format \"ndjson\" is not supported, falling back to json\n"
-	if got := errOut.String(); got != wantWarning {
-		t.Fatalf("stderr bytes = %q, want %q", got, wantWarning)
-	}
-}
-
-func TestServicePaginate_BusinessErrorsWriteRawAndRemainUnmarked(t *testing.T) {
-	businessResponse := map[string]interface{}{
-		"code": 123456,
-		"msg":  "fixture business error",
-		"data": map[string]interface{}{"detail": "business failed"},
-	}
-	tests := []struct {
-		name   string
-		format output.Format
-		jqExpr string
-	}{
-		{name: "jq", format: output.FormatJSON, jqExpr: ".data.items"},
-		{name: "default_json", format: output.FormatJSON},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ac, out, errOut, reg := newServicePaginateTestHarness(t)
-			reg.Register(&httpmock.Stub{
-				URL:  "/open-apis/test/v1/items",
-				Body: businessResponse,
-			})
-
-			err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
-				tt.format, tt.jqExpr, out, errOut, "lark-cli test items list",
-				client.PaginationOptions{PageDelay: -1}, ac.CheckResponse)
-
-			if err == nil {
-				t.Fatal("servicePaginate() error = nil, want business error")
-			}
-			if errs.IsRaw(err) {
-				t.Fatalf("errs.IsRaw(error) = true, want current servicePaginate pass-through behavior")
-			}
-			assertServicePaginateJSONBytes(t, out.Bytes(), businessResponse)
-			if bytes.Contains(out.Bytes(), []byte(`"ok": true`)) {
-				t.Fatalf("business-error stdout contains a success envelope:\n%s", out.Bytes())
-			}
-			if got := errOut.String(); got != "" {
-				t.Fatalf("stderr bytes = %q, want empty", got)
-			}
-		})
-	}
-}
-
-func TestServicePaginate_TransportErrorsRemainUnmarked(t *testing.T) {
-	tests := []struct {
-		name   string
-		format output.Format
-		jqExpr string
-	}{
-		{name: "jq_paginate_all", format: output.FormatJSON, jqExpr: ".data.items"},
-		{name: "stream_pages", format: output.FormatNDJSON},
-		{name: "default_paginate_all", format: output.FormatJSON},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ac, out, errOut, _ := newServicePaginateTestHarness(t)
-
-			err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
-				tt.format, tt.jqExpr, out, errOut, "lark-cli test items list",
-				client.PaginationOptions{PageDelay: -1}, ac.CheckResponse)
-
-			if err == nil {
-				t.Fatal("servicePaginate() error = nil, want transport error")
-			}
-			if errs.IsRaw(err) {
-				t.Fatalf("errs.IsRaw(error) = true, want current servicePaginate pass-through behavior")
-			}
-			if got := out.String(); got != "" {
-				t.Fatalf("stdout bytes = %q, want empty", got)
-			}
-			if got := errOut.String(); got != "" {
-				t.Fatalf("stderr bytes = %q, want empty", got)
-			}
-		})
-	}
-}
-
-func TestServicePaginate_StreamBusinessErrorRemainsUnmarked(t *testing.T) {
-	ac, out, errOut, reg := newServicePaginateTestHarness(t)
-	reg.Register(&httpmock.Stub{
-		URL: "/open-apis/test/v1/items",
-		Body: map[string]interface{}{
-			"code": 123456,
-			"msg":  "fixture business error",
-			"data": map[string]interface{}{},
-		},
-	})
-
-	err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
-		output.FormatNDJSON, "", out, errOut, "lark-cli test items list",
-		client.PaginationOptions{PageDelay: -1}, ac.CheckResponse)
-
-	if err == nil {
-		t.Fatal("servicePaginate() error = nil, want business error")
-	}
-	if errs.IsRaw(err) {
-		t.Fatalf("errs.IsRaw(error) = true, want current servicePaginate pass-through behavior")
-	}
-	if got := out.String(); got != "" {
-		t.Fatalf("stdout bytes = %q, want empty", got)
-	}
-	if got := errOut.String(); got != "" {
-		t.Fatalf("stderr bytes = %q, want empty", got)
-	}
-}

cmd/service/testmain_test.go

@@ -1,39 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package service
-
-import (
-	"os"
-	"testing"
-
-	"github.com/larksuite/cli/internal/registry/registrytest"
-)
-
-// TestMain isolates service command tests from the host machine: config (and
-// the registry cache under it) is redirected to a temp dir, then the registry
-// is seeded from the tracked fixture and initialized eagerly. Tests pass on a
-// clean checkout with no network, no `make fetch_meta`, and no user cache.
-//
-// Note: os.Exit skips deferred functions, so cleanup runs explicitly after
-// m.Run before exiting.
-func TestMain(m *testing.M) {
-	root, err := os.MkdirTemp("", "lark-cli-cmd-service-test-*")
-	if err != nil {
-		println("cmd/service test setup: MkdirTemp failed:", err.Error())
-		os.Exit(2)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", root); err != nil {
-		println("cmd/service test setup: Setenv failed:", err.Error())
-		os.RemoveAll(root)
-		os.Exit(2)
-	}
-	if err := registrytest.Seed(root); err != nil {
-		println("cmd/service test setup: registrytest.Seed failed:", err.Error())
-		os.RemoveAll(root)
-		os.Exit(2)
-	}
-	code := m.Run()
-	os.RemoveAll(root)
-	os.Exit(code)
-}

cmd/startup_brand_test.go

@@ -5,7 +5,6 @@ package cmd
 
 import (
 	"context"
-	"flag"
 	"fmt"
 	"os"
 	"os/exec"
@@ -13,34 +12,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/google/uuid"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/registry"
 )
 
-const startupBrandHelperEnv = "GO_TEST_STARTUP_BRAND_HELPER"
-
-var _ = flag.String("startup-brand-helper", "", "internal startup brand test helper nonce")
-
-func isStartupBrandHelper() bool {
-	return startupBrandHelperEnabled(os.Getenv(startupBrandHelperEnv), startupBrandHelperNonce(os.Args))
-}
-
-func startupBrandHelperEnabled(envNonce, argNonce string) bool {
-	return envNonce != "" && envNonce == argNonce
-}
-
-func startupBrandHelperNonce(args []string) string {
-	const prefix = "-startup-brand-helper="
-	for _, arg := range args {
-		if strings.HasPrefix(arg, prefix) {
-			return strings.TrimPrefix(arg, prefix)
-		}
-	}
-	return ""
-}
-
 func TestResolveStartupBrand_Precedence(t *testing.T) {
 	tmp := t.TempDir()
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", tmp)
@@ -78,7 +54,7 @@ func TestResolveStartupBrand_Precedence(t *testing.T) {
 // sync.Once, so the brand must be injected before the first catalog access.
 // It runs in a subprocess because the registry is process-global.
 func TestStartupBrandReachesRegistry_RealStartupOrder(t *testing.T) {
-	if isStartupBrandHelper() {
+	if os.Getenv("GO_TEST_STARTUP_BRAND_HELPER") == "1" {
 		// Helper: replicate Execute()'s build wiring with a lark config.
 		buildInternal(
 			context.Background(), cmdutil.InvocationContext{},
@@ -95,11 +71,9 @@ func TestStartupBrandReachesRegistry_RealStartupOrder(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	nonce := uuid.NewString()
-	t.Setenv(startupBrandHelperEnv, nonce)
 	cmd := exec.Command(os.Args[0], "-test.run", "TestStartupBrandReachesRegistry_RealStartupOrder")
-	cmd.Args = append(cmd.Args, "-startup-brand-helper="+nonce)
 	cmd.Env = append(os.Environ(),
+		"GO_TEST_STARTUP_BRAND_HELPER=1",
 		"LARKSUITE_CLI_CONFIG_DIR="+tmp,
 		"LARKSUITE_CLI_REMOTE_META=off", // no network during the subprocess build
 	)
@@ -111,33 +85,3 @@ func TestStartupBrandReachesRegistry_RealStartupOrder(t *testing.T) {
 		t.Errorf("registry brand after real startup order = %s, want lark", out)
 	}
 }
-
-func TestStartupBrandHelperRequiresMatchingCommandNonce(t *testing.T) {
-	for _, tt := range []struct {
-		name     string
-		envNonce string
-		argNonce string
-		want     bool
-	}{
-		{name: "neither set"},
-		{name: "ambient environment only", envNonce: "ambient"},
-		{name: "command argument only", argNonce: "command"},
-		{name: "mismatch", envNonce: "ambient", argNonce: "command"},
-		{name: "matching", envNonce: "nonce", argNonce: "nonce", want: true},
-	} {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := startupBrandHelperEnabled(tt.envNonce, tt.argNonce); got != tt.want {
-				t.Fatalf("startupBrandHelperEnabled() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestStartupBrandHelperNonce(t *testing.T) {
-	if got := startupBrandHelperNonce([]string{"test", "-test.run", "brand"}); got != "" {
-		t.Fatalf("startupBrandHelperNonce() = %q, want empty", got)
-	}
-	if got := startupBrandHelperNonce([]string{"test", "-startup-brand-helper=nonce"}); got != "nonce" {
-		t.Fatalf("startupBrandHelperNonce() = %q, want nonce", got)
-	}
-}

cmd/testmain_test.go

@@ -1,46 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmd
-
-import (
-	"os"
-	"testing"
-
-	"github.com/larksuite/cli/internal/registry/registrytest"
-)
-
-// TestMain isolates command-tree tests from the host machine: config (and the
-// registry cache under it) is redirected to a temp dir, then the registry is
-// seeded from the tracked fixture and initialized eagerly. Tests pass on a
-// clean checkout with no network, no `make fetch_meta`, and no user cache.
-//
-// Note: os.Exit skips deferred functions, so cleanup runs explicitly after
-// m.Run before exiting.
-func TestMain(m *testing.M) {
-	if isStartupBrandHelper() {
-		// Re-exec helper subprocess (startup_brand_test.go): the parent test
-		// already provides an isolated config dir and disables remote metadata,
-		// and the helper must own the first registry Init to prove the startup
-		// order — do not seed or eagerly initialize here.
-		os.Exit(m.Run())
-	}
-	root, err := os.MkdirTemp("", "lark-cli-cmd-test-*")
-	if err != nil {
-		println("cmd test setup: MkdirTemp failed:", err.Error())
-		os.Exit(2)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", root); err != nil {
-		println("cmd test setup: Setenv failed:", err.Error())
-		os.RemoveAll(root)
-		os.Exit(2)
-	}
-	if err := registrytest.Seed(root); err != nil {
-		println("cmd test setup: registrytest.Seed failed:", err.Error())
-		os.RemoveAll(root)
-		os.Exit(2)
-	}
-	code := m.Run()
-	os.RemoveAll(root)
-	os.Exit(code)
-}

cmd/update/testmain_test.go

@@ -1,23 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmdupdate
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestMain(m *testing.M) {
-	root, err := os.MkdirTemp("", "lark-cli-update-test-*")
-	if err != nil {
-		panic(err)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", filepath.Join(root, "config")); err != nil {
-		panic(err)
-	}
-	code := m.Run()
-	_ = os.RemoveAll(root)
-	os.Exit(code)
-}

cmd/update/update_test.go

@@ -24,8 +24,6 @@ import (
 	"github.com/larksuite/cli/internal/skillscheck"
 )
 
-const runLiveSkillsTestsEnv = "LARKSUITE_CLI_RUN_LIVE_SKILLS_TESTS"
-
 // newTestFactory creates a test factory with minimal config.
 func newTestFactory(t *testing.T) (*cmdutil.Factory, *bytes.Buffer, *bytes.Buffer) {
 	t.Helper()
@@ -33,17 +31,13 @@ func newTestFactory(t *testing.T) (*cmdutil.Factory, *bytes.Buffer, *bytes.Buffe
 	return f, stdout, stderr
 }
 
-// mockDetect sets up newUpdater to return an Updater with the given DetectResult
-// and fully mocked skills operations. Tests that only care about install-method
-// detection must never fall through to the real npx skills CLI.
+// mockDetect sets up newUpdater to return an Updater with the given DetectResult.
 func mockDetect(t *testing.T, result selfupdate.DetectResult) {
 	t.Helper()
 	origNew := newUpdater
 	newUpdater = func() *selfupdate.Updater {
 		u := selfupdate.New()
 		u.DetectOverride = func() selfupdate.DetectResult { return result }
-		u.SkillsIndexFetchOverride = successfulSkillsIndexFetch()
-		u.SkillsCommandOverride = successfulSkillsCommand()
 		return u
 	}
 	t.Cleanup(func() { newUpdater = origNew })
@@ -110,18 +104,6 @@ func successfulSkillsCommand() func(args ...string) *selfupdate.NpmResult {
 	}
 }
 
-func mockSkillsSync(t *testing.T) {
-	t.Helper()
-	origNew := newUpdater
-	newUpdater = func() *selfupdate.Updater {
-		u := selfupdate.New()
-		u.SkillsIndexFetchOverride = successfulSkillsIndexFetch()
-		u.SkillsCommandOverride = successfulSkillsCommand()
-		return u
-	}
-	t.Cleanup(func() { newUpdater = origNew })
-}
-
 func TestUpdatePnpm_JSON(t *testing.T) {
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 	f, stdout, _ := newTestFactory(t)
@@ -246,9 +228,6 @@ func TestNormalizeVersion(t *testing.T) {
 }
 
 func TestUpdateAlreadyUpToDate_JSON(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	mockSkillsSync(t)
-
 	f, stdout, _ := newTestFactory(t)
 
 	cmd := NewCmdUpdate(f)
@@ -277,9 +256,6 @@ func TestUpdateAlreadyUpToDate_JSON(t *testing.T) {
 }
 
 func TestUpdateAlreadyUpToDate_Human(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	mockSkillsSync(t)
-
 	f, _, stderr := newTestFactory(t)
 
 	cmd := NewCmdUpdate(f)
@@ -305,7 +281,6 @@ func TestUpdateAlreadyUpToDate_Human(t *testing.T) {
 }
 
 func TestUpdateManual_JSON(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 	f, stdout, _ := newTestFactory(t)
 	cmd := NewCmdUpdate(f)
 	cmd.SetArgs([]string{"--json"})
@@ -337,7 +312,6 @@ func TestUpdateManual_JSON(t *testing.T) {
 }
 
 func TestUpdateManual_Human(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 	f, _, stderr := newTestFactory(t)
 	cmd := NewCmdUpdate(f)
 	cmd.SetArgs([]string{})
@@ -1187,7 +1161,6 @@ func TestRunSkillsAndState_DedupForceBypass(t *testing.T) {
 	}
 	called := false
 	updater := &selfupdate.Updater{
-		SkillsIndexFetchOverride: successfulSkillsIndexFetch(),
 		SkillsCommandOverride: func(args ...string) *selfupdate.NpmResult {
 			called = true
 			return successfulSkillsCommand()(args...)
@@ -1204,10 +1177,7 @@ func TestRunSkillsAndState_DedupForceBypass(t *testing.T) {
 
 func TestRunSkillsAndState_SuccessWritesState(t *testing.T) {
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	updater := &selfupdate.Updater{
-		SkillsIndexFetchOverride: successfulSkillsIndexFetch(),
-		SkillsCommandOverride:    successfulSkillsCommand(),
-	}
+	updater := &selfupdate.Updater{SkillsCommandOverride: successfulSkillsCommand()}
 	got := runSkillsAndState(updater, newTestIO(), "1.0.21", false)
 	if got == nil || got.Err != nil {
 		t.Fatalf("runSkillsAndState() = %+v, want non-nil with nil Err", got)
@@ -1227,7 +1197,6 @@ func TestRunSkillsAndState_FailureKeepsOldState(t *testing.T) {
 		t.Fatal(err)
 	}
 	updater := &selfupdate.Updater{
-		SkillsIndexFetchOverride: successfulSkillsIndexFetch(),
 		SkillsCommandOverride: func(args ...string) *selfupdate.NpmResult {
 			r := &selfupdate.NpmResult{}
 			r.Err = fmt.Errorf("npx failed")
@@ -1544,133 +1513,28 @@ func TestEmitSkillsTextHints_Success(t *testing.T) {
 	}
 }
 
-// liveSkillsIsolationEnv is the single source of truth for the user-state
-// directories a live skills test must redirect under the temporary home. It
-// covers the CLI's own config, the agent homes the skills CLI installs into,
-// the XDG dirs it derives paths from (XDG_STATE_HOME holds its global
-// .skill-lock.json), and the npm/npx overrides that take precedence over
-// HOME-derived defaults (both cases: npm reads npm_config_* case-insensitively).
-func liveSkillsIsolationEnv(home string) map[string]string {
-	return map[string]string{
-		"HOME":                     home,
-		"USERPROFILE":              home,
-		"APPDATA":                  filepath.Join(home, "AppData", "Roaming"),
-		"LOCALAPPDATA":             filepath.Join(home, "AppData", "Local"),
-		"XDG_CONFIG_HOME":          filepath.Join(home, ".config"),
-		"XDG_DATA_HOME":            filepath.Join(home, ".local", "share"),
-		"XDG_STATE_HOME":           filepath.Join(home, ".local", "state"),
-		"CODEX_HOME":               filepath.Join(home, ".codex"),
-		"CLAUDE_CONFIG_DIR":        filepath.Join(home, ".claude"),
-		"LARKSUITE_CLI_CONFIG_DIR": filepath.Join(home, ".lark-cli"),
-		"npm_config_cache":         filepath.Join(home, ".npm-cache"),
-		"NPM_CONFIG_CACHE":         filepath.Join(home, ".npm-cache"),
-		"npm_config_prefix":        filepath.Join(home, ".npm-global"),
-		"NPM_CONFIG_PREFIX":        filepath.Join(home, ".npm-global"),
-		"npm_config_userconfig":    filepath.Join(home, ".npmrc"),
-		"NPM_CONFIG_USERCONFIG":    filepath.Join(home, ".npmrc"),
-	}
-}
-
-func prepareLiveSkillsIntegration(t *testing.T) string {
-	t.Helper()
-	if os.Getenv(runLiveSkillsTestsEnv) != "1" {
-		t.Skipf("live skills integration test disabled; set %s=1 to run", runLiveSkillsTestsEnv)
-	}
-
-	home := t.TempDir()
-	for key, value := range liveSkillsIsolationEnv(home) {
-		t.Setenv(key, value)
-	}
-	return home
-}
-
-func TestPrepareLiveSkillsIntegration(t *testing.T) {
-	reachedAfterGate := false
-	t.Run("requires explicit opt-in", func(t *testing.T) {
-		t.Setenv(runLiveSkillsTestsEnv, "")
-		prepareLiveSkillsIntegration(t)
-		reachedAfterGate = true
-	})
-	if reachedAfterGate {
-		t.Fatal("prepareLiveSkillsIntegration continued without explicit opt-in")
-	}
-
-	t.Run("isolates user directories", func(t *testing.T) {
-		t.Setenv(runLiveSkillsTestsEnv, "1")
-		home := prepareLiveSkillsIntegration(t)
-		// Pin the isolation contract by key: removing a variable from
-		// liveSkillsIsolationEnv must fail this list, and every redirected
-		// value must live under the temporary home.
-		required := []string{
-			"HOME", "USERPROFILE", "APPDATA", "LOCALAPPDATA",
-			"XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_STATE_HOME",
-			"CODEX_HOME", "CLAUDE_CONFIG_DIR", "LARKSUITE_CLI_CONFIG_DIR",
-			"npm_config_cache", "NPM_CONFIG_CACHE",
-			"npm_config_prefix", "NPM_CONFIG_PREFIX",
-			"npm_config_userconfig", "NPM_CONFIG_USERCONFIG",
-		}
-		env := liveSkillsIsolationEnv(home)
-		for _, key := range required {
-			expected, ok := env[key]
-			if !ok {
-				t.Errorf("liveSkillsIsolationEnv dropped required key %s", key)
-				continue
-			}
-			if !strings.HasPrefix(expected, home) {
-				t.Errorf("%s = %q escapes temporary home %q", key, expected, home)
-			}
-			if got := os.Getenv(key); got != expected {
-				t.Errorf("%s = %q, want %q", key, got, expected)
-			}
-		}
-	})
-}
-
-// seedLiveSkillsGlobal verifies the real npx skills CLI is reachable, installs
-// lark-calendar into the isolated global skills dir, and returns the parsed
-// global skills list. The caller opted in explicitly, so every missing
-// precondition is a hard failure — skipping would report "nothing verified"
-// as a green run.
-func seedLiveSkillsGlobal(t *testing.T) []string {
-	t.Helper()
+// TestUpdateCommand_RealSkillsSyncRewritesState is a live integration test that
+// verifies "lark-cli update" correctly triggers skills sync and rewrites the
+// state file. It calls the real npx skills CLI, so the test is skipped when
+// npx or the skills registry is unavailable (e.g. no network or fork PRs).
+func TestUpdateCommand_RealSkillsSyncRewritesState(t *testing.T) {
+	// Phase 1: Verify the real npx skills CLI is available; skip otherwise.
 	if _, err := exec.LookPath("npx"); err != nil {
-		t.Fatalf("live skills tests opted in but npx not found in PATH: %v", err)
+		t.Skipf("npx not found in PATH: %v", err)
 	}
-	// Three sequential npx runs against a cold cache (the isolated home starts
-	// empty) can be slow; with Fatal-on-timeout semantics the budget errs on
-	// the generous side.
-	ctx, cancel := context.WithTimeout(context.Background(), 180*time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
 	defer cancel()
 	if err := exec.CommandContext(ctx, "npx", "-y", "skills", "add", "https://open.feishu.cn", "--list").Run(); err != nil {
-		t.Fatalf("live skills tests opted in but real skills CLI unavailable: %v", err)
-	}
-	if err := exec.CommandContext(ctx, "npx", "-y", "skills", "add", "https://open.feishu.cn", "-s", "lark-calendar", "-g", "-y").Run(); err != nil {
-		t.Fatalf("failed to seed isolated global skills: %v", err)
+		t.Skipf("real skills CLI unavailable: %v", err)
 	}
 	globalOut, err := exec.CommandContext(ctx, "npx", "-y", "skills", "ls", "-g").Output()
 	if err != nil {
-		t.Fatalf("real global skills CLI unavailable: %v", err)
+		t.Skipf("real global skills CLI unavailable: %v", err)
 	}
 	localSkills := skillscheck.ParseSkillsList(string(globalOut))
-	if len(localSkills) == 0 {
-		t.Fatal("seeded lark-calendar but global skills list is empty")
-	}
 	if err := ctx.Err(); err != nil {
-		t.Fatalf("real skills CLI availability check timed out: %v", err)
+		t.Skipf("real skills CLI availability check timed out: %v", err)
 	}
-	return localSkills
-}
-
-// TestUpdateCommand_RealSkillsSyncRewritesState is a live integration test that
-// verifies "lark-cli update" correctly triggers skills sync and rewrites the
-// state file. It calls the real npx skills CLI and only runs with explicit
-// opt-in. All user directories are redirected to a temporary home.
-func TestUpdateCommand_RealSkillsSyncRewritesState(t *testing.T) {
-	prepareLiveSkillsIntegration(t)
-
-	// Phase 1: Verify the real npx skills CLI is available and seed the
-	// isolated global skills install.
-	localSkills := seedLiveSkillsGlobal(t)
 
 	// Phase 2: Seed a previous sync state simulating an upgrade from v1.0.19.
 	// lark-doc and lark-mail are recorded as skipped/deleted, meaning the user
@@ -1766,17 +1630,26 @@ func TestUpdateCommand_RealSkillsSyncRewritesState(t *testing.T) {
 // not exist (cold start), the update command installs all official skills and
 // writes a fresh state file. No skill should appear in SkippedDeletedSkills
 // because there is no previous state to preserve user deletions from.
-// This is a live integration test that calls the real npx skills CLI and only
-// runs with explicit opt-in. All user directories are redirected to a temporary
-// home.
+// This is a live integration test that calls the real npx skills CLI; it is
+// skipped when npx or the skills registry is unavailable.
 func TestUpdateCommand_SkillsSyncColdStart(t *testing.T) {
-	prepareLiveSkillsIntegration(t)
-
-	// Phase 1: Verify the real npx skills CLI is available and seed one known
-	// official skill into the isolated global install. Cold start means no
-	// skills-state.json — locally installed skills may still exist, and seeding
-	// one keeps the Phase 4 per-skill assertions from running zero times.
-	localSkills := seedLiveSkillsGlobal(t)
+	// Phase 1: Verify the real npx skills CLI is available; skip otherwise.
+	if _, err := exec.LookPath("npx"); err != nil {
+		t.Skipf("npx not found in PATH: %v", err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
+	defer cancel()
+	if err := exec.CommandContext(ctx, "npx", "-y", "skills", "add", "https://open.feishu.cn", "--list").Run(); err != nil {
+		t.Skipf("real skills CLI unavailable: %v", err)
+	}
+	globalOut, err := exec.CommandContext(ctx, "npx", "-y", "skills", "ls", "-g").Output()
+	if err != nil {
+		t.Skipf("real global skills CLI unavailable: %v", err)
+	}
+	localSkills := skillscheck.ParseSkillsList(string(globalOut))
+	if err := ctx.Err(); err != nil {
+		t.Skipf("real skills CLI availability check timed out: %v", err)
+	}
 
 	// Phase 2: Use an isolated config dir with no pre-existing skills-state.json.
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())

events/application/menu.go

@@ -1,107 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package application
-
-import (
-	"context"
-	"encoding/json"
-	"strings"
-
-	"github.com/larksuite/cli/internal/event"
-)
-
-// BotMenuOutput is the flattened shape for application.bot.menu_v6.
-type BotMenuOutput struct {
-	Type            string `json:"type"                         desc:"Event type; always application.bot.menu_v6"`
-	EventID         string `json:"event_id,omitempty"           desc:"Globally unique event ID; safe for deduplication"`
-	Timestamp       string `json:"timestamp,omitempty"          desc:"Event delivery time (ms timestamp string); prefers header.create_time" kind:"timestamp_ms"`
-	AppID           string `json:"app_id,omitempty"             desc:"Application ID from the event header"`
-	TenantKey       string `json:"tenant_key,omitempty"         desc:"Tenant key from the event header"`
-	EventKey        string `json:"event_key,omitempty"          desc:"Developer-defined bot menu event key"`
-	MenuTimestamp   string `json:"menu_timestamp,omitempty"     desc:"Menu click timestamp from the event body"                           kind:"timestamp_ms"`
-	OperatorID      string `json:"operator_id,omitempty"        desc:"Operator open_id; kept as a short alias of operator_open_id"        kind:"open_id"`
-	OperatorOpenID  string `json:"operator_open_id,omitempty"   desc:"Operator open_id"                                                   kind:"open_id"`
-	OperatorUnionID string `json:"operator_union_id,omitempty"  desc:"Operator union_id"                                                  kind:"union_id"`
-	OperatorUserID  string `json:"operator_user_id,omitempty"   desc:"Operator user_id"                                                   kind:"user_id"`
-	OperatorName    string `json:"operator_name,omitempty"      desc:"Operator display name"`
-}
-
-func processBotMenu(_ context.Context, _ event.APIClient, raw *event.RawEvent, _ map[string]string) (json.RawMessage, error) {
-	var envelope struct {
-		Header struct {
-			EventID    string `json:"event_id"`
-			EventType  string `json:"event_type"`
-			CreateTime string `json:"create_time"`
-			AppID      string `json:"app_id"`
-			TenantKey  string `json:"tenant_key"`
-		} `json:"header"`
-		Event struct {
-			EventKey  string          `json:"event_key"`
-			Timestamp json.RawMessage `json:"timestamp"`
-			Operator  struct {
-				OperatorID struct {
-					OpenID  string `json:"open_id"`
-					UnionID string `json:"union_id"`
-					UserID  string `json:"user_id"`
-				} `json:"operator_id"`
-				OperatorName string `json:"operator_name"`
-			} `json:"operator"`
-		} `json:"event"`
-	}
-	if err := json.Unmarshal(raw.Payload, &envelope); err != nil {
-		return raw.Payload, nil //nolint:nilerr // passthrough on malformed payload so consumers still see the event
-	}
-
-	menuTimestamp := timestampMillisString(envelope.Event.Timestamp)
-	timestamp := envelope.Header.CreateTime
-	if timestamp == "" {
-		timestamp = menuTimestamp
-	}
-	operatorID := envelope.Event.Operator.OperatorID.OpenID
-
-	out := &BotMenuOutput{
-		Type:            eventTypeBotMenuV6,
-		EventID:         envelope.Header.EventID,
-		Timestamp:       timestamp,
-		AppID:           envelope.Header.AppID,
-		TenantKey:       envelope.Header.TenantKey,
-		EventKey:        envelope.Event.EventKey,
-		MenuTimestamp:   menuTimestamp,
-		OperatorID:      operatorID,
-		OperatorOpenID:  operatorID,
-		OperatorUnionID: envelope.Event.Operator.OperatorID.UnionID,
-		OperatorUserID:  envelope.Event.Operator.OperatorID.UserID,
-		OperatorName:    envelope.Event.Operator.OperatorName,
-	}
-	return json.Marshal(out)
-}
-
-func rawScalarString(raw json.RawMessage) string {
-	s := strings.TrimSpace(string(raw))
-	if s == "" || s == "null" {
-		return ""
-	}
-	var text string
-	if err := json.Unmarshal(raw, &text); err == nil {
-		return text
-	}
-	return s
-}
-
-func timestampMillisString(raw json.RawMessage) string {
-	s := rawScalarString(raw)
-	if len(s) == 10 && allDigits(s) {
-		return s + "000"
-	}
-	return s
-}
-
-func allDigits(s string) bool {
-	for _, r := range s {
-		if r < '0' || r > '9' {
-			return false
-		}
-	}
-	return s != ""
-}

events/application/menu_test.go

@@ -1,227 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package application
-
-import (
-	"context"
-	"encoding/json"
-	"reflect"
-	"testing"
-	"time"
-
-	"github.com/larksuite/cli/internal/event"
-)
-
-func TestKeysBotMenuMetadata(t *testing.T) {
-	keys := Keys()
-	if len(keys) != 1 {
-		t.Fatalf("len(Keys()) = %d, want 1", len(keys))
-	}
-
-	def := keys[0]
-	if def.Key != eventTypeBotMenuV6 {
-		t.Errorf("Key = %q, want %q", def.Key, eventTypeBotMenuV6)
-	}
-	if def.EventType != eventTypeBotMenuV6 {
-		t.Errorf("EventType = %q, want %q", def.EventType, eventTypeBotMenuV6)
-	}
-	if def.SubscriptionType != "" {
-		t.Errorf("SubscriptionType = %q, want default event subscription", def.SubscriptionType)
-	}
-	if def.Schema.Custom == nil {
-		t.Fatal("Schema.Custom is nil")
-	}
-	if def.Schema.Custom.Type != reflect.TypeOf(BotMenuOutput{}) {
-		t.Errorf("custom type = %v, want BotMenuOutput", def.Schema.Custom.Type)
-	}
-	if def.Schema.Native != nil {
-		t.Fatal("Schema.Native must be nil for processed output")
-	}
-	if def.Process == nil {
-		t.Fatal("Process is nil")
-	}
-	if !reflect.DeepEqual(def.AuthTypes, []string{"bot"}) {
-		t.Errorf("AuthTypes = %#v", def.AuthTypes)
-	}
-	if !reflect.DeepEqual(def.RequiredConsoleEvents, []string{eventTypeBotMenuV6}) {
-		t.Errorf("RequiredConsoleEvents = %#v", def.RequiredConsoleEvents)
-	}
-}
-
-func TestBotMenuRegistersCleanly(t *testing.T) {
-	const key = eventTypeBotMenuV6
-	event.UnregisterKeyForTest(key)
-	t.Cleanup(func() { event.UnregisterKeyForTest(key) })
-
-	for _, def := range Keys() {
-		event.RegisterKey(def)
-	}
-	if _, ok := event.Lookup(key); !ok {
-		t.Fatalf("event.Lookup(%q) not registered", key)
-	}
-}
-
-func TestProcessBotMenu(t *testing.T) {
-	payload := `{
-		"schema": "2.0",
-		"header": {
-			"event_id": "ev_menu_001",
-			"event_type": "application.bot.menu_v6",
-			"create_time": "1776409469273",
-			"app_id": "cli_test",
-			"tenant_key": "tenant_test"
-		},
-		"event": {
-			"event_key": "start_eval",
-			"timestamp": 1776409469000,
-			"operator": {
-				"operator_id": {
-					"open_id": "ou_operator",
-					"union_id": "on_operator",
-					"user_id": "user_operator"
-				},
-				"operator_name": "Test User"
-			}
-		}
-	}`
-	out := runBotMenu(t, payload)
-
-	if out.Type != eventTypeBotMenuV6 {
-		t.Errorf("Type = %q, want %q", out.Type, eventTypeBotMenuV6)
-	}
-	if out.EventID != "ev_menu_001" {
-		t.Errorf("EventID = %q", out.EventID)
-	}
-	if out.Timestamp != "1776409469273" {
-		t.Errorf("Timestamp = %q", out.Timestamp)
-	}
-	if out.EventKey != "start_eval" {
-		t.Errorf("EventKey = %q", out.EventKey)
-	}
-	if out.MenuTimestamp != "1776409469000" {
-		t.Errorf("MenuTimestamp = %q", out.MenuTimestamp)
-	}
-	if out.OperatorID != "ou_operator" || out.OperatorOpenID != "ou_operator" {
-		t.Errorf("OperatorID/OperatorOpenID = %q/%q", out.OperatorID, out.OperatorOpenID)
-	}
-	if out.OperatorUnionID != "on_operator" {
-		t.Errorf("OperatorUnionID = %q", out.OperatorUnionID)
-	}
-	if out.OperatorUserID != "user_operator" {
-		t.Errorf("OperatorUserID = %q", out.OperatorUserID)
-	}
-	if out.OperatorName != "Test User" {
-		t.Errorf("OperatorName = %q", out.OperatorName)
-	}
-	if out.AppID != "cli_test" || out.TenantKey != "tenant_test" {
-		t.Errorf("AppID/TenantKey = %q/%q", out.AppID, out.TenantKey)
-	}
-}
-
-func TestProcessBotMenuStringTimestampFallback(t *testing.T) {
-	payload := `{
-		"schema": "2.0",
-		"header": {
-			"event_id": "ev_menu_002",
-			"event_type": "application.bot.menu_v6"
-		},
-		"event": {
-			"event_key": "start_eval",
-			"timestamp": "1776409469001",
-			"operator": {
-				"operator_id": {"open_id": "ou_operator"}
-			}
-		}
-	}`
-	out := runBotMenu(t, payload)
-
-	if out.Timestamp != "1776409469001" {
-		t.Errorf("Timestamp fallback = %q", out.Timestamp)
-	}
-	if out.MenuTimestamp != "1776409469001" {
-		t.Errorf("MenuTimestamp = %q", out.MenuTimestamp)
-	}
-}
-
-func TestProcessBotMenuSecondsTimestampFallback(t *testing.T) {
-	payload := `{
-		"schema": "2.0",
-		"header": {
-			"event_id": "ev_menu_seconds",
-			"event_type": "application.bot.menu_v6"
-		},
-		"event": {
-			"event_key": "start_eval",
-			"timestamp": 1694592375,
-			"operator": {
-				"operator_id": {"open_id": "ou_operator"}
-			}
-		}
-	}`
-	out := runBotMenu(t, payload)
-
-	if out.Timestamp != "1694592375000" {
-		t.Errorf("Timestamp fallback = %q, want seconds normalized to milliseconds", out.Timestamp)
-	}
-	if out.MenuTimestamp != "1694592375000" {
-		t.Errorf("MenuTimestamp = %q, want seconds normalized to milliseconds", out.MenuTimestamp)
-	}
-}
-
-func TestProcessBotMenuTypeUsesLocalConstant(t *testing.T) {
-	payload := `{
-		"schema": "2.0",
-		"header": {
-			"event_id": "ev_menu_003",
-			"event_type": "unexpected.event_type",
-			"create_time": "1776409469275"
-		},
-		"event": {
-			"event_key": "start_eval",
-			"operator": {
-				"operator_id": {"open_id": "ou_operator"}
-			}
-		}
-	}`
-	out := runBotMenu(t, payload)
-
-	if out.Type != eventTypeBotMenuV6 {
-		t.Errorf("Type = %q, want %q", out.Type, eventTypeBotMenuV6)
-	}
-}
-
-func TestProcessBotMenuMalformedPayload(t *testing.T) {
-	raw := &event.RawEvent{
-		EventID:   "ev_bad",
-		EventType: eventTypeBotMenuV6,
-		Payload:   json.RawMessage(`not json`),
-		Timestamp: time.Now(),
-	}
-	got, err := processBotMenu(context.Background(), nil, raw, nil)
-	if err != nil {
-		t.Fatalf("Process should swallow parse errors, got %v", err)
-	}
-	if string(got) != "not json" {
-		t.Errorf("malformed fallback output = %q, want original bytes", string(got))
-	}
-}
-
-func runBotMenu(t *testing.T, payload string) BotMenuOutput {
-	t.Helper()
-	raw := &event.RawEvent{
-		EventID:   "ev_test",
-		EventType: eventTypeBotMenuV6,
-		Payload:   json.RawMessage(payload),
-		Timestamp: time.Now(),
-	}
-	got, err := processBotMenu(context.Background(), nil, raw, nil)
-	if err != nil {
-		t.Fatalf("processBotMenu: %v", err)
-	}
-	var out BotMenuOutput
-	if err := json.Unmarshal(got, &out); err != nil {
-		t.Fatalf("unmarshal output: %v\n%s", err, got)
-	}
-	return out
-}

events/application/register.go

@@ -1,31 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-// Package application registers Application-domain EventKeys.
-package application
-
-import (
-	"reflect"
-
-	"github.com/larksuite/cli/internal/event"
-)
-
-const eventTypeBotMenuV6 = "application.bot.menu_v6"
-
-// Keys returns all Application-domain EventKey definitions.
-func Keys() []event.KeyDefinition {
-	return []event.KeyDefinition{
-		{
-			Key:         eventTypeBotMenuV6,
-			DisplayName: "Bot menu",
-			Description: "Triggered when a user clicks a custom bot menu item whose action is configured as a push event.",
-			EventType:   eventTypeBotMenuV6,
-			Schema: event.SchemaDef{
-				Custom: &event.SchemaSpec{Type: reflect.TypeOf(BotMenuOutput{})},
-			},
-			Process:               processBotMenu,
-			AuthTypes:             []string{"bot"},
-			RequiredConsoleEvents: []string{eventTypeBotMenuV6},
-		},
-	}
-}

events/register.go

@@ -5,7 +5,6 @@
 package events
 
 import (
-	"github.com/larksuite/cli/events/application"
 	"github.com/larksuite/cli/events/approval"
 	"github.com/larksuite/cli/events/im"
 	"github.com/larksuite/cli/events/minutes"
@@ -18,7 +17,6 @@ import (
 // Mail is intentionally omitted in this phase.
 func init() {
 	all := [][]event.KeyDefinition{
-		application.Keys(),
 		approval.Keys(),
 		im.Keys(),
 		minutes.Keys(),

internal/auth/testmain_test.go

@@ -1,23 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package auth
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestMain(m *testing.M) {
-	root, err := os.MkdirTemp("", "lark-cli-internal-auth-test-*")
-	if err != nil {
-		panic(err)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_LOG_DIR", filepath.Join(root, "logs")); err != nil {
-		panic(err)
-	}
-	code := m.Run()
-	_ = os.RemoveAll(root)
-	os.Exit(code)
-}

internal/client/response.go

@@ -132,14 +132,16 @@ func HandleResponse(resp *larkcore.ApiResp, opts ResponseOptions) error {
 			})
 		}
 
-		emitter := output.NewEmitter(output.EmitterConfig{
-			Out:            opts.Out,
-			ErrOut:         opts.ErrOut,
-			CommandPath:    opts.CommandPath,
-			Identity:       string(identity),
-			NoticeProvider: output.GetNotice,
-		})
-		return emitter.Success(result, output.EmitOptions{Format: opts.Format.String()})
+		// Content safety scanning for non-JSON presentation formats.
+		scanResult := output.ScanForSafety(opts.CommandPath, result, opts.ErrOut)
+		if scanResult.Blocked {
+			return scanResult.BlockErr
+		}
+		if scanResult.Alert != nil {
+			output.WriteAlertWarning(opts.ErrOut, scanResult.Alert)
+		}
+		output.FormatValue(opts.Out, result, opts.Format)
+		return nil
 	}
 
 	// Non-JSON (binary) responses.

internal/client/response_test.go

@@ -18,7 +18,6 @@ import (
 
 	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/httpmock"
 	"github.com/larksuite/cli/internal/output"
 	"github.com/larksuite/cli/internal/vfs/localfileio"
 )
@@ -240,87 +239,6 @@ func TestHandleResponse_JSON(t *testing.T) {
 	}
 }
 
-func TestHandleResponse_NonJSONFormatsEmitExactStructuredResponseBytes(t *testing.T) {
-	tests := []struct {
-		name   string
-		format output.Format
-		want   string
-	}{
-		{
-			name:   "ndjson",
-			format: output.FormatNDJSON,
-			want:   "{\"id\":\"1\",\"name\":\"Alice\"}\n{\"id\":\"2\",\"name\":\"Bob\"}\n",
-		},
-		{
-			name:   "table",
-			format: output.FormatTable,
-			want:   "id  name \n──  ─────\n1   Alice\n2   Bob  \n",
-		},
-		{
-			name:   "csv",
-			format: output.FormatCSV,
-			want:   "id,name\n1,Alice\n2,Bob\n",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-			reg := &httpmock.Registry{}
-			reg.Register(&httpmock.Stub{
-				Method: http.MethodGet,
-				URL:    "/open-apis/test/v1/items",
-				Body: map[string]interface{}{
-					"code": 0,
-					"msg":  "ok",
-					"data": map[string]interface{}{
-						"items": []interface{}{
-							map[string]interface{}{"id": "1", "name": "Alice"},
-							map[string]interface{}{"id": "2", "name": "Bob"},
-						},
-						"has_more": false,
-					},
-				},
-			})
-
-			httpResp, err := httpmock.NewClient(reg).Get("https://open.feishu.cn/open-apis/test/v1/items")
-			if err != nil {
-				t.Fatalf("fixture request failed: %v", err)
-			}
-			body, err := io.ReadAll(httpResp.Body)
-			_ = httpResp.Body.Close()
-			if err != nil {
-				t.Fatalf("read fixture response: %v", err)
-			}
-			resp := &larkcore.ApiResp{
-				StatusCode: httpResp.StatusCode,
-				Header:     httpResp.Header.Clone(),
-				RawBody:    body,
-			}
-
-			var out bytes.Buffer
-			var errOut bytes.Buffer
-			err = HandleResponse(resp, ResponseOptions{
-				Format:      tt.format,
-				Identity:    core.AsBot,
-				Out:         &out,
-				ErrOut:      &errOut,
-				CommandPath: "lark-cli api GET",
-			})
-			if err != nil {
-				t.Fatalf("HandleResponse() error = %v, want nil", err)
-			}
-			if got := out.String(); got != tt.want {
-				t.Fatalf("stdout byte mismatch\ngot (%d bytes):\n%q\nwant (%d bytes):\n%q", len(got), got, len(tt.want), tt.want)
-			}
-			if got := errOut.String(); got != "" {
-				t.Fatalf("stderr bytes = %q, want empty", got)
-			}
-			reg.Verify(t)
-		})
-	}
-}
-
 func TestHandleResponse_JSONWithJqUsesSuccessEnvelope(t *testing.T) {
 	body := []byte(`{"code":0,"msg":"ok","data":{"id":"1"}}`)
 	resp := newApiResp(body, map[string]string{"Content-Type": "application/json"})

internal/cmdutil/factory_default.go

@@ -22,7 +22,6 @@ import (
 	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/keychain"
 	"github.com/larksuite/cli/internal/registry"
-	"github.com/larksuite/cli/internal/riskcontrol"
 	_ "github.com/larksuite/cli/internal/security/contentsafety" // register content safety provider
 	"github.com/larksuite/cli/internal/transport"
 	_ "github.com/larksuite/cli/internal/vfs/localfileio" // register default FileIO provider
@@ -34,7 +33,7 @@ import (
 //	Phase 1: HttpClient (no credential dependency)
 //	Phase 2: Credential (sole data source for account info)
 //	Phase 3: Config derived from Credential
-//	Phase 4: LarkClient derived from Credential and workspace policy
+//	Phase 4: LarkClient derived from Credential
 func NewDefault(streams *IOStreams, inv InvocationContext) *Factory {
 	streams = normalizeStreams(streams)
 	f := &Factory{
@@ -55,10 +54,9 @@ func NewDefault(streams *IOStreams, inv InvocationContext) *Factory {
 
 	// Phase 0: FileIO provider (no dependency)
 	f.FileIOProvider = fileio.GetProvider()
-	workspaceConfig := core.NewConfigSnapshot()
 
 	// Phase 1: HttpClient (no credential dependency)
-	f.HttpClient = cachedHttpClientFunc(f, workspaceConfig)
+	f.HttpClient = cachedHttpClientFunc(f)
 
 	// Phase 2: Credential (sole data source)
 	// Keychain is read via closure so callers can replace f.Keychain after construction.
@@ -69,7 +67,7 @@ func NewDefault(streams *IOStreams, inv InvocationContext) *Factory {
 		ErrOut:     f.IOStreams.ErrOut,
 	})
 
-	// Phase 3: Runtime config contains resolved account data only.
+	// Phase 3: Config derived from Credential via an explicit conversion boundary.
 	f.Config = sync.OnceValues(func() (*core.CliConfig, error) {
 		acct, err := f.Credential.ResolveAccount(context.Background())
 		if err != nil {
@@ -80,9 +78,8 @@ func NewDefault(streams *IOStreams, inv InvocationContext) *Factory {
 		return cfg, nil
 	})
 
-	// Phase 4: LarkClient composes account data and workspace policy at the SDK
-	// transport boundary.
-	f.LarkClient = cachedLarkClientFunc(f, workspaceConfig)
+	// Phase 4: LarkClient from Credential (placeholder AppSecret)
+	f.LarkClient = cachedLarkClientFunc(f)
 
 	return f
 }
@@ -111,16 +108,13 @@ func safeRedirectPolicy(req *http.Request, via []*http.Request) error {
 // .StderrIsTerminal field, which tests set directly.
 var warnIfProxied = transport.WarnIfProxied
 
-func cachedHttpClientFunc(f *Factory, workspaceConfig workspaceConfigSource) func() (*http.Client, error) {
+func cachedHttpClientFunc(f *Factory) func() (*http.Client, error) {
 	return sync.OnceValues(func() (*http.Client, error) {
 		if f.IOStreams.StderrIsTerminal {
 			warnIfProxied(f.IOStreams.ErrOut)
 		}
 
-		hostSignalSource := resolveSDKHostSignalSource(workspaceConfig)
-
 		var rt http.RoundTripper = transport.Shared()
-		rt = riskcontrol.NewTransport(rt, hostSignalSource)
 		rt = &RetryTransport{Base: rt}
 		rt = &SecurityHeaderTransport{Base: rt}
 		rt = &auth.SecurityPolicyTransport{Base: rt} // Add our global response interceptor
@@ -134,7 +128,7 @@ func cachedHttpClientFunc(f *Factory, workspaceConfig workspaceConfigSource) fun
 	})
 }
 
-func cachedLarkClientFunc(f *Factory, workspaceConfig workspaceConfigSource) func() (*lark.Client, error) {
+func cachedLarkClientFunc(f *Factory) func() (*lark.Client, error) {
 	return sync.OnceValues(func() (*lark.Client, error) {
 		acct, err := f.Credential.ResolveAccount(context.Background())
 		if err != nil {
@@ -148,15 +142,8 @@ func cachedLarkClientFunc(f *Factory, workspaceConfig workspaceConfigSource) fun
 		if f.IOStreams.StderrIsTerminal {
 			warnIfProxied(f.IOStreams.ErrOut)
 		}
-		hostSignalSource := resolveSDKHostSignalSource(workspaceConfig)
-		var sdkBase http.RoundTripper = transport.Shared()
-		// The innermost SDK boundary always strips reserved host-signal headers;
-		// a nil source makes it strip-only when workspace policy disables signal
-		// collection.
-		sdkBase = riskcontrol.NewTransport(sdkBase, hostSignalSource)
-		sdkTransport := wrapSDKTransport(sdkBase)
 		opts = append(opts, lark.WithHttpClient(&http.Client{
-			Transport:     sdkTransport,
+			Transport:     buildSDKTransport(),
 			CheckRedirect: safeRedirectPolicy,
 		}))
 		ep := core.ResolveEndpoints(acct.Brand)
@@ -165,8 +152,9 @@ func cachedLarkClientFunc(f *Factory, workspaceConfig workspaceConfigSource) fun
 	})
 }
 
-func wrapSDKTransport(next http.RoundTripper) http.RoundTripper {
-	var sdkTransport http.RoundTripper = &RetryTransport{Base: next}
+func buildSDKTransport() http.RoundTripper {
+	var sdkTransport http.RoundTripper = transport.Shared()
+	sdkTransport = &RetryTransport{Base: sdkTransport}
 	sdkTransport = &UserAgentTransport{Base: sdkTransport}
 	sdkTransport = &BuildHeaderTransport{Base: sdkTransport}
 	sdkTransport = &auth.SecurityPolicyTransport{Base: sdkTransport}

internal/cmdutil/factory_http_test.go

@@ -6,15 +6,10 @@ package cmdutil
 import (
 	"io"
 	"testing"
-
-	"github.com/larksuite/cli/internal/core"
 )
 
 func TestCachedHttpClientFunc_ReturnsSameInstance(t *testing.T) {
-	isEnabled := false
-	f, _, _, _ := TestFactory(t, &core.CliConfig{AppID: "test-app"})
-	f.IOStreams.ErrOut = io.Discard
-	fn := cachedHttpClientFunc(f, staticWorkspaceConfig{config: &core.MultiAppConfig{RiskControl: &isEnabled}})
+	fn := cachedHttpClientFunc(&Factory{IOStreams: &IOStreams{ErrOut: io.Discard}})
 
 	c1, err := fn()
 	if err != nil {
@@ -34,10 +29,7 @@ func TestCachedHttpClientFunc_ReturnsSameInstance(t *testing.T) {
 }
 
 func TestCachedHttpClientFunc_HasTimeout(t *testing.T) {
-	isEnabled := false
-	f, _, _, _ := TestFactory(t, &core.CliConfig{AppID: "test-app"})
-	f.IOStreams.ErrOut = io.Discard
-	fn := cachedHttpClientFunc(f, staticWorkspaceConfig{config: &core.MultiAppConfig{RiskControl: &isEnabled}})
+	fn := cachedHttpClientFunc(&Factory{IOStreams: &IOStreams{ErrOut: io.Discard}})
 	c, _ := fn()
 	if c.Timeout == 0 {
 		t.Error("expected non-zero timeout")
@@ -45,10 +37,7 @@ func TestCachedHttpClientFunc_HasTimeout(t *testing.T) {
 }
 
 func TestCachedHttpClientFunc_HasRedirectPolicy(t *testing.T) {
-	isEnabled := false
-	f, _, _, _ := TestFactory(t, &core.CliConfig{AppID: "test-app"})
-	f.IOStreams.ErrOut = io.Discard
-	fn := cachedHttpClientFunc(f, staticWorkspaceConfig{config: &core.MultiAppConfig{RiskControl: &isEnabled}})
+	fn := cachedHttpClientFunc(&Factory{IOStreams: &IOStreams{ErrOut: io.Discard}})
 	c, _ := fn()
 	if c.CheckRedirect == nil {
 		t.Error("expected CheckRedirect to be set (safeRedirectPolicy)")

internal/cmdutil/factory_proxy_warn_test.go

@@ -8,7 +8,6 @@ import (
 	"testing"
 
 	_ "github.com/larksuite/cli/extension/credential/env" // registers the env-backed account provider
-	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/envvars"
 )
 
@@ -37,15 +36,13 @@ var proxyWarnGateCases = []struct {
 // TestCachedHttpClientFunc_ProxyWarnGate verifies the http-client init path
 // invokes WarnIfProxied only when stderr is an interactive terminal.
 func TestCachedHttpClientFunc_ProxyWarnGate(t *testing.T) {
-	isEnabled := false
 	for _, tc := range proxyWarnGateCases {
 		t.Run(tc.name, func(t *testing.T) {
 			calls := installProxyWarnSpy(t)
 
-			f, _, _, _ := TestFactory(t, &core.CliConfig{AppID: "test-app"})
-			f.IOStreams.ErrOut = io.Discard
-			f.IOStreams.StderrIsTerminal = tc.terminal
-			fn := cachedHttpClientFunc(f, staticWorkspaceConfig{config: &core.MultiAppConfig{RiskControl: &isEnabled}})
+			fn := cachedHttpClientFunc(&Factory{IOStreams: &IOStreams{
+				ErrOut: io.Discard, StderrIsTerminal: tc.terminal,
+			}})
 			if _, err := fn(); err != nil {
 				t.Fatalf("http client init: %v", err)
 			}
@@ -76,7 +73,7 @@ func TestCachedLarkClientFunc_ProxyWarnGate(t *testing.T) {
 			// normalizeStreams copies the struct (out := *s), so the
 			// StderrIsTerminal field survives into f.IOStreams.
 			f := NewDefault(&IOStreams{ErrOut: io.Discard, StderrIsTerminal: tc.terminal}, InvocationContext{})
-			if _, err := cachedLarkClientFunc(f, nil)(); err != nil {
+			if _, err := cachedLarkClientFunc(f)(); err != nil {
 				t.Fatalf("lark client init: %v", err)
 			}
 

internal/cmdutil/localfile.go

@@ -1,36 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmdutil
-
-import (
-	"io/fs"
-
-	"github.com/larksuite/cli/extension/fileio"
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/internal/vfs"
-)
-
-// StatLocalFile returns metadata for a path in the process filesystem namespace.
-// It is intended for advisory validation; callers must validate the opened file
-// again before using its contents.
-func StatLocalFile(path string) (fs.FileInfo, error) {
-	localPath, err := validate.LocalInputPath(path)
-	if err != nil {
-		return nil, &fileio.PathValidationError{Err: err}
-	}
-	return vfs.Stat(localPath)
-}
-
-// OpenLocalFile opens a path in the process filesystem namespace.
-// Absolute and relative paths are accepted. It is the shared replacement for
-// direct os.Open/os.ReadFile use in commands that intentionally read local
-// paths outside the workspace sandbox. Callers inspect the returned descriptor
-// before reading so validation and use apply to the same opened file.
-func OpenLocalFile(path string) (fs.File, error) {
-	localPath, err := validate.LocalInputPath(path)
-	if err != nil {
-		return nil, &fileio.PathValidationError{Err: err}
-	}
-	return vfs.Open(localPath)
-}

internal/cmdutil/localfile_test.go

@@ -1,96 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmdutil
-
-import (
-	"errors"
-	"io"
-	"io/fs"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/larksuite/cli/extension/fileio"
-	"github.com/larksuite/cli/internal/vfs"
-)
-
-func TestOpenLocalFile_AcceptsAbsoluteAndParentRelativePaths(t *testing.T) {
-	root := t.TempDir()
-	workDir := filepath.Join(root, "work")
-	if err := os.Mkdir(workDir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	path := filepath.Join(root, "input.txt")
-	if err := os.WriteFile(path, []byte("content"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	TestChdir(t, workDir)
-
-	for _, input := range []string{path, filepath.Join("..", "input.txt")} {
-		f, err := OpenLocalFile(input)
-		if err != nil {
-			t.Fatalf("OpenLocalFile(%q) error = %v", input, err)
-		}
-		got, readErr := io.ReadAll(f)
-		closeErr := f.Close()
-		if readErr != nil || closeErr != nil || string(got) != "content" {
-			t.Fatalf("OpenLocalFile(%q) content=%q read=%v close=%v", input, got, readErr, closeErr)
-		}
-	}
-}
-
-func TestOpenLocalFile_RejectsInvalidInput(t *testing.T) {
-	if _, err := OpenLocalFile("input\n.txt"); !errors.Is(err, fileio.ErrPathValidation) {
-		t.Fatalf("OpenLocalFile() error = %v, want ErrPathValidation", err)
-	}
-}
-
-func TestStatLocalFile_ReturnsMetadata(t *testing.T) {
-	info, err := StatLocalFile(t.TempDir())
-	if err != nil {
-		t.Fatalf("StatLocalFile() error = %v", err)
-	}
-	if !info.IsDir() {
-		t.Fatalf("StatLocalFile() mode = %v, want directory", info.Mode())
-	}
-}
-
-func TestOpenLocalFile_DoesNotStatBeforeOpen(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "input.txt")
-	if err := os.WriteFile(path, []byte("content"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-
-	previous := vfs.DefaultFS
-	counting := &countingLocalFileFS{FS: previous}
-	vfs.DefaultFS = counting
-	t.Cleanup(func() { vfs.DefaultFS = previous })
-
-	f, err := OpenLocalFile(path)
-	if err != nil {
-		t.Fatalf("OpenLocalFile() error = %v", err)
-	}
-	if err := f.Close(); err != nil {
-		t.Fatal(err)
-	}
-	if counting.openCalls != 1 || counting.statCalls != 0 {
-		t.Fatalf("OpenLocalFile() calls: Open=%d Stat=%d, want Open=1 Stat=0", counting.openCalls, counting.statCalls)
-	}
-}
-
-type countingLocalFileFS struct {
-	vfs.FS
-	openCalls int
-	statCalls int
-}
-
-func (f *countingLocalFileFS) Open(name string) (*os.File, error) {
-	f.openCalls++
-	return f.FS.Open(name)
-}
-
-func (f *countingLocalFileFS) Stat(name string) (fs.FileInfo, error) {
-	f.statCalls++
-	return f.FS.Stat(name)
-}

internal/cmdutil/risk_control.go

@@ -1,28 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmdutil
-
-import (
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/riskcontrol"
-)
-
-type workspaceConfigSource interface {
-	MultiAppConfig() (*core.MultiAppConfig, error)
-}
-
-// resolveSDKHostSignalSource applies workspace policy at the SDK transport
-// boundary.
-func resolveSDKHostSignalSource(config workspaceConfigSource) riskcontrol.Source {
-	if config == nil {
-		return nil
-	}
-	workspace, configErr := config.MultiAppConfig()
-	// Default-on means an existing config with no explicit preference. Absent
-	// or unreadable config cannot authorize host-signal collection.
-	if configErr != nil || !workspace.RiskControlEnabled() {
-		return nil
-	}
-	return riskcontrol.NewHostSource()
-}

internal/cmdutil/risk_control_test.go

@@ -1,45 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmdutil
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/larksuite/cli/internal/core"
-)
-
-type staticWorkspaceConfig struct {
-	config *core.MultiAppConfig
-	err    error
-}
-
-func (s staticWorkspaceConfig) MultiAppConfig() (*core.MultiAppConfig, error) {
-	return s.config, s.err
-}
-
-func TestResolveSDKHostSignalSource(t *testing.T) {
-	disabled := false
-	tests := []struct {
-		name       string
-		config     workspaceConfigSource
-		wantSource bool
-	}{
-		{name: "workspace default on", config: staticWorkspaceConfig{config: &core.MultiAppConfig{}}, wantSource: true},
-		{name: "workspace opt-out", config: staticWorkspaceConfig{config: &core.MultiAppConfig{RiskControl: &disabled}}},
-		{name: "missing config", config: staticWorkspaceConfig{err: errors.New("file does not exist")}},
-		{name: "unreadable config", config: staticWorkspaceConfig{err: errors.New("permission denied")}},
-		{name: "nil config value", config: staticWorkspaceConfig{}},
-		{name: "nil config source"},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			got := resolveSDKHostSignalSource(test.config)
-			if (got != nil) != test.wantSource {
-				t.Fatalf("resolveSDKHostSignalSource() = %T, wantSource %t", got, test.wantSource)
-			}
-		})
-	}
-}

internal/cmdutil/testmain_test.go

@@ -1,30 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmdutil
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestMain(m *testing.M) {
-	// Default-factory tests initialize the registry and resolve config. Keep
-	// them deterministic: never read the developer's real ~/.lark-cli and
-	// prevent background remote-metadata refreshes from touching user state.
-	root, err := os.MkdirTemp("", "lark-cli-cmdutil-test-*")
-	if err != nil {
-		println("internal/cmdutil test setup: MkdirTemp failed:", err.Error())
-		os.Exit(2)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", filepath.Join(root, "config")); err != nil {
-		panic(err)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_REMOTE_META", "off"); err != nil {
-		panic(err)
-	}
-	code := m.Run()
-	_ = os.RemoveAll(root)
-	os.Exit(code)
-}

internal/cmdutil/transport_test.go

@@ -15,7 +15,6 @@ import (
 
 	exttransport "github.com/larksuite/cli/extension/transport"
 	internalauth "github.com/larksuite/cli/internal/auth"
-	"github.com/larksuite/cli/internal/riskcontrol"
 )
 
 type roundTripFunc func(*http.Request) (*http.Response, error)
@@ -92,13 +91,13 @@ func TestRetryTransport_DefaultNoRetry(t *testing.T) {
 }
 
 // ---------------------------------------------------------------------------
-// wrapSDKTransport chain composition
+// buildSDKTransport chain composition
 // ---------------------------------------------------------------------------
 
-func TestWrapSDKTransport_IncludesRetryTransport(t *testing.T) {
-	transport := wrapSDKTransport(riskcontrol.NewTransport(http.DefaultTransport, nil))
+func TestBuildSDKTransport_IncludesRetryTransport(t *testing.T) {
+	transport := buildSDKTransport()
 
-	// Chain: SecurityPolicy → BuildHeader → UserAgent → Retry → RiskControl → Base
+	// Chain: SecurityPolicy → BuildHeader → UserAgent → Retry → Base
 	sec, ok := transport.(*internalauth.SecurityPolicyTransport)
 	if !ok {
 		t.Fatalf("outer transport type = %T, want *auth.SecurityPolicyTransport", transport)
@@ -111,23 +110,18 @@ func TestWrapSDKTransport_IncludesRetryTransport(t *testing.T) {
 	if !ok {
 		t.Fatalf("layer after BuildHeader = %T, want *UserAgentTransport", bh.Base)
 	}
-	retry, ok := ua.Base.(*RetryTransport)
-	if !ok {
+	if _, ok := ua.Base.(*RetryTransport); !ok {
 		t.Fatalf("inner transport type = %T, want *RetryTransport", ua.Base)
 	}
-	if _, ok := retry.Base.(*riskcontrol.Transport); !ok {
-		t.Fatalf("layer after Retry = %T, want *riskcontrol.Transport", retry.Base)
-	}
 }
 
-func TestWrapSDKTransport_WithExtension(t *testing.T) {
-	previous := exttransport.GetProvider()
+func TestBuildSDKTransport_WithExtension(t *testing.T) {
 	exttransport.Register(&stubTransportProvider{})
-	t.Cleanup(func() { exttransport.Register(previous) })
+	t.Cleanup(func() { exttransport.Register(nil) })
 
-	transport := wrapSDKTransport(riskcontrol.NewTransport(http.DefaultTransport, nil))
+	transport := buildSDKTransport()
 
-	// Chain: extensionMiddleware → SecurityPolicy → BuildHeader → UserAgent → Retry → RiskControl → Base
+	// Chain: extensionMiddleware → SecurityPolicy → BuildHeader → UserAgent → Retry → Base
 	mid, ok := transport.(*extensionMiddleware)
 	if !ok {
 		t.Fatalf("outer transport type = %T, want *extensionMiddleware", transport)
@@ -144,23 +138,17 @@ func TestWrapSDKTransport_WithExtension(t *testing.T) {
 	if !ok {
 		t.Fatalf("layer after BuildHeader = %T, want *UserAgentTransport", bh.Base)
 	}
-	retry, ok := ua.Base.(*RetryTransport)
-	if !ok {
+	if _, ok := ua.Base.(*RetryTransport); !ok {
 		t.Fatalf("innermost transport type = %T, want *RetryTransport", ua.Base)
 	}
-	if _, ok := retry.Base.(*riskcontrol.Transport); !ok {
-		t.Fatalf("layer after Retry = %T, want *riskcontrol.Transport", retry.Base)
-	}
 }
 
-func TestWrapSDKTransport_WithoutExtension(t *testing.T) {
-	previous := exttransport.GetProvider()
+func TestBuildSDKTransport_WithoutExtension(t *testing.T) {
 	exttransport.Register(nil)
-	t.Cleanup(func() { exttransport.Register(previous) })
 
-	transport := wrapSDKTransport(riskcontrol.NewTransport(http.DefaultTransport, nil))
+	transport := buildSDKTransport()
 
-	// Chain: SecurityPolicy → BuildHeader → UserAgent → Retry → RiskControl → Base
+	// Chain: SecurityPolicy → BuildHeader → UserAgent → Retry → Base
 	sec, ok := transport.(*internalauth.SecurityPolicyTransport)
 	if !ok {
 		t.Fatalf("outer transport type = %T, want *auth.SecurityPolicyTransport", transport)
@@ -173,13 +161,9 @@ func TestWrapSDKTransport_WithoutExtension(t *testing.T) {
 	if !ok {
 		t.Fatalf("layer after BuildHeader = %T, want *UserAgentTransport", bh.Base)
 	}
-	retry, ok := ua.Base.(*RetryTransport)
-	if !ok {
+	if _, ok := ua.Base.(*RetryTransport); !ok {
 		t.Fatalf("inner transport type = %T, want *RetryTransport", ua.Base)
 	}
-	if _, ok := retry.Base.(*riskcontrol.Transport); !ok {
-		t.Fatalf("layer after Retry = %T, want *riskcontrol.Transport", retry.Base)
-	}
 }
 
 // ---------------------------------------------------------------------------
@@ -277,40 +261,6 @@ func (buildTamperingInterceptor) PreRoundTrip(req *http.Request) func(*http.Resp
 	return nil
 }
 
-type riskHeaderTamperingInterceptor struct{}
-
-func (riskHeaderTamperingInterceptor) PreRoundTrip(req *http.Request) func(*http.Response, error) {
-	req.Header.Set(riskcontrol.HeaderOSType, "extension-value")
-	req.Header.Set(riskcontrol.HeaderProductModel, "extension-value")
-	return nil
-}
-
-func TestWrapSDKTransport_StripsExtensionRiskHeaders(t *testing.T) {
-	previous := exttransport.GetProvider()
-	exttransport.Register(&stubTransportProvider{interceptor: riskHeaderTamperingInterceptor{}})
-	t.Cleanup(func() { exttransport.Register(previous) })
-
-	var received http.Header
-	network := roundTripFunc(func(req *http.Request) (*http.Response, error) {
-		received = req.Header.Clone()
-		return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}, nil
-	})
-	req, err := http.NewRequest(http.MethodGet, "https://open.feishu.cn/open-apis/test", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	req.Header.Set("Authorization", "Bearer token")
-
-	resp, err := wrapSDKTransport(riskcontrol.NewTransport(network, nil)).RoundTrip(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	resp.Body.Close()
-	if received.Get(riskcontrol.HeaderOSType) != "" || received.Get(riskcontrol.HeaderProductModel) != "" {
-		t.Fatalf("extension risk headers reached network: %v", received)
-	}
-}
-
 // TestBuildHeaderTransport_SDKChain_OverridesTamperedHeader verifies that the
 // X-Cli-Build header is force-written by BuildHeaderTransport in the SDK
 // transport chain, even when an extension tries to delete or spoof it. This
@@ -327,7 +277,7 @@ func TestBuildHeaderTransport_SDKChain_OverridesTamperedHeader(t *testing.T) {
 	exttransport.Register(&stubTransportProvider{interceptor: buildTamperingInterceptor{}})
 	t.Cleanup(func() { exttransport.Register(nil) })
 
-	// Replicate the SDK chain layering used by wrapSDKTransport.
+	// Replicate the SDK chain layering used by buildSDKTransport.
 	var base http.RoundTripper = http.DefaultTransport
 	base = &RetryTransport{Base: base}
 	base = &UserAgentTransport{Base: base}

internal/core/config.go

@@ -60,18 +60,11 @@ func (a *AppConfig) ProfileName() string {
 // MultiAppConfig is the multi-app config file format.
 type MultiAppConfig struct {
 	StrictMode  StrictMode  `json:"strictMode,omitempty"`
-	RiskControl *bool       `json:"riskControl,omitempty"`
 	CurrentApp  string      `json:"currentApp,omitempty"`
 	PreviousApp string      `json:"previousApp,omitempty"`
 	Apps        []AppConfig `json:"apps"`
 }
 
-// RiskControlEnabled resolves the workspace policy. An omitted preference
-// keeps the default-on account-protection behavior.
-func (m *MultiAppConfig) RiskControlEnabled() bool {
-	return m != nil && (m.RiskControl == nil || *m.RiskControl)
-}
-
 // CurrentAppConfig returns the currently active app config.
 // Resolution priority: profileOverride > CurrentApp field > Apps[0].
 func (m *MultiAppConfig) CurrentAppConfig(profileOverride string) *AppConfig {

internal/core/config_snapshot.go

@@ -1,37 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package core
-
-import (
-	"io/fs"
-	"sync"
-)
-
-// ConfigSnapshot lazily captures one stable view of config.json for a CLI
-// invocation. All runtime consumers share the same load result so account and
-// workspace policy resolution cannot observe different file revisions. Callers
-// must treat the returned config as read-only.
-type ConfigSnapshot struct {
-	load func() (*MultiAppConfig, error)
-}
-
-// NewConfigSnapshot creates a lazily loaded invocation-scoped config snapshot.
-func NewConfigSnapshot() *ConfigSnapshot {
-	return newConfigSnapshot(LoadMultiAppConfig)
-}
-
-func newConfigSnapshot(load func() (*MultiAppConfig, error)) *ConfigSnapshot {
-	if load == nil {
-		return &ConfigSnapshot{}
-	}
-	return &ConfigSnapshot{load: sync.OnceValues(load)}
-}
-
-// MultiAppConfig returns the captured persistent config and load error.
-func (s *ConfigSnapshot) MultiAppConfig() (*MultiAppConfig, error) {
-	if s == nil || s.load == nil {
-		return nil, fs.ErrNotExist
-	}
-	return s.load()
-}

internal/core/config_snapshot_test.go

@@ -1,58 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package core
-
-import (
-	"errors"
-	"io/fs"
-	"testing"
-)
-
-func TestConfigSnapshotLoadsOnce(t *testing.T) {
-	calls := 0
-	want := &MultiAppConfig{}
-	snapshot := newConfigSnapshot(func() (*MultiAppConfig, error) {
-		calls++
-		return want, nil
-	})
-
-	for range 2 {
-		config, err := snapshot.MultiAppConfig()
-		if err != nil {
-			t.Fatal(err)
-		}
-		if config != want {
-			t.Fatal("snapshot returned a different config instance")
-		}
-	}
-	if calls != 1 {
-		t.Fatalf("config loads = %d, want 1", calls)
-	}
-}
-
-func TestConfigSnapshotZeroValueIsMissing(t *testing.T) {
-	config, err := (&ConfigSnapshot{}).MultiAppConfig()
-	if config != nil || !errors.Is(err, fs.ErrNotExist) {
-		t.Fatalf("MultiAppConfig() = (%v, %v), want (nil, fs.ErrNotExist)", config, err)
-	}
-}
-
-func TestConfigSnapshotCachesError(t *testing.T) {
-	calls := 0
-	want := errors.New("load failed")
-	snapshot := newConfigSnapshot(func() (*MultiAppConfig, error) {
-		calls++
-		return nil, want
-	})
-
-	for range 2 {
-		config, err := snapshot.MultiAppConfig()
-		if config != nil || !errors.Is(err, want) {
-			t.Fatalf("MultiAppConfig() = (%v, %v), want (nil, %v)", config, err, want)
-		}
-	}
-	if calls != 1 {
-		t.Fatalf("config loads = %d, want 1", calls)
-	}
-}

internal/core/config_test.go

@@ -60,9 +60,7 @@ func TestAppConfig_LangOmitEmpty(t *testing.T) {
 }
 
 func TestMultiAppConfig_RoundTrip(t *testing.T) {
-	disabled := false
 	config := &MultiAppConfig{
-		RiskControl: &disabled,
 		Apps: []AppConfig{{
 			AppId: "cli_test", AppSecret: PlainSecret("s"),
 			Brand: BrandLark, Lang: "zh", Users: []AppUser{},
@@ -86,9 +84,6 @@ func TestMultiAppConfig_RoundTrip(t *testing.T) {
 	if got.Apps[0].Brand != BrandLark {
 		t.Errorf("Brand = %q, want %q", got.Apps[0].Brand, BrandLark)
 	}
-	if got.RiskControl == nil || *got.RiskControl {
-		t.Errorf("RiskControl = %v, want explicit false", got.RiskControl)
-	}
 }
 
 func TestResolveConfigFromMulti_RejectsSecretKeyMismatch(t *testing.T) {

internal/event/testmain_test.go

@@ -1,23 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package event
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestMain(m *testing.M) {
-	root, err := os.MkdirTemp("", "lark-cli-event-test-*")
-	if err != nil {
-		panic(err)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", filepath.Join(root, "config")); err != nil {
-		panic(err)
-	}
-	code := m.Run()
-	_ = os.RemoveAll(root)
-	os.Exit(code)
-}

internal/keychain/testmain_test.go

@@ -1,28 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package keychain
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestMain(m *testing.M) {
-	root, err := os.MkdirTemp("", "lark-cli-keychain-test-*")
-	if err != nil {
-		panic(err)
-	}
-	for key, value := range map[string]string{
-		"LARKSUITE_CLI_DATA_DIR": filepath.Join(root, "data"),
-		"LARKSUITE_CLI_LOG_DIR":  filepath.Join(root, "logs"),
-	} {
-		if err := os.Setenv(key, value); err != nil {
-			panic(err)
-		}
-	}
-	code := m.Run()
-	_ = os.RemoveAll(root)
-	os.Exit(code)
-}

internal/output/csv.go

@@ -7,91 +7,70 @@ import (
 	"encoding/csv"
 	"fmt"
 	"io"
+	"os"
 )
 
 // FormatAsCSV formats data as CSV (with header) and writes it to w.
 func FormatAsCSV(w io.Writer, data interface{}) {
-	// Match the other legacy wrappers: surface only a marshal failure (as the
-	// JSON fallback historically did); plain write failures stay swallowed.
-	if err := WriteCSV(w, data); isOutputMarshalError(err) {
-		legacyStderrf("json marshal error: %v\n", err)
-	}
-}
-
-// WriteCSV formats data as CSV and returns marshal or write errors.
-func WriteCSV(w io.Writer, data interface{}) error {
-	return WriteCSVPaginated(w, data, true)
+	FormatAsCSVPaginated(w, data, true)
 }
 
 // FormatAsCSVPaginated formats data as CSV with pagination awareness.
 // When isFirstPage is true, outputs the header row; otherwise only data rows.
 func FormatAsCSVPaginated(w io.Writer, data interface{}, isFirstPage bool) {
-	if err := WriteCSVPaginated(w, data, isFirstPage); isOutputMarshalError(err) {
-		legacyStderrf("json marshal error: %v\n", err)
-	}
-}
-
-// WriteCSVPaginated formats data as CSV and returns marshal or write errors.
-func WriteCSVPaginated(w io.Writer, data interface{}, isFirstPage bool) error {
 	rows, cols, isList := prepareRows(data)
 	if cols == nil {
 		if isList {
-			_, err := fmt.Fprintln(w, "(empty)")
-			return err
+			fmt.Fprintln(w, "(empty)")
 		} else {
-			return WriteJSON(w, data)
+			PrintJson(w, data)
 		}
+		return
 	}
 
 	if len(rows) == 0 {
 		if isFirstPage {
-			_, err := fmt.Fprintln(w, "(empty)")
-			return err
+			fmt.Fprintln(w, "(empty)")
 		}
-		return nil
+		return
 	}
 
 	if !isList {
 		// Single object: key,value rows
 		cw := csv.NewWriter(w)
 		if isFirstPage {
-			if err := cw.Write([]string{"key", "value"}); err != nil {
-				return err
-			}
+			cw.Write([]string{"key", "value"})
 		}
 		for _, col := range cols {
-			if err := cw.Write([]string{col, rows[0][col]}); err != nil {
-				return err
-			}
+			cw.Write([]string{col, rows[0][col]})
 		}
-		return flushCSV(cw)
+		flushCSV(cw)
+		return
 	}
 
-	return writeCSVRows(w, rows, cols, isFirstPage)
+	writeCSVRows(w, rows, cols, isFirstPage)
 }
 
 // writeCSVRows writes CSV data rows (and optionally header) using the given columns.
-func writeCSVRows(w io.Writer, rows []map[string]string, cols []string, writeHeader bool) error {
+func writeCSVRows(w io.Writer, rows []map[string]string, cols []string, writeHeader bool) {
 	cw := csv.NewWriter(w)
 	if writeHeader {
-		if err := cw.Write(cols); err != nil {
-			return err
-		}
+		cw.Write(cols)
 	}
 	for _, row := range rows {
 		record := make([]string, len(cols))
 		for i, col := range cols {
 			record[i] = row[col]
 		}
-		if err := cw.Write(record); err != nil {
-			return err
-		}
+		cw.Write(record)
 	}
-	return flushCSV(cw)
+	flushCSV(cw)
 }
 
-// flushCSV flushes the csv.Writer and returns any write error.
-func flushCSV(cw *csv.Writer) error {
+// flushCSV flushes the csv.Writer and reports any write error to stderr.
+func flushCSV(cw *csv.Writer) {
 	cw.Flush()
-	return cw.Error()
+	if err := cw.Error(); err != nil {
+		fmt.Fprintf(os.Stderr, "csv write error: %v\n", err)
+	}
 }

internal/output/emit.go

@@ -50,11 +50,10 @@ func wrapBlockError(alert *extcs.Alert) error {
 
 // WriteAlertWarning writes a human-readable content-safety warning to w.
 // Used by non-JSON output paths (pretty, table, csv) in warn mode.
-func WriteAlertWarning(w io.Writer, alert *extcs.Alert) error {
+func WriteAlertWarning(w io.Writer, alert *extcs.Alert) {
 	if alert == nil {
-		return nil
+		return
 	}
-	_, err := fmt.Fprintf(w, "warning: content safety alert from %s (rules: %s)\n",
+	fmt.Fprintf(w, "warning: content safety alert from %s (rules: %s)\n",
 		alert.Provider, strings.Join(alert.MatchedRules, ", "))
-	return err
 }

internal/output/emitter.go

@@ -1,336 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package output
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"maps"
-
-	"github.com/larksuite/cli/errs"
-)
-
-// NoticeProvider supplies the notice attached to a structured envelope.
-// The provider is captured by an Emitter so emission never reads the global
-// PendingNotice hook implicitly.
-type NoticeProvider func() map[string]interface{}
-
-// PrettyRenderer writes the human-readable representation of one result.
-// colorEnabled is the terminal capability captured when the Emitter is built.
-type PrettyRenderer func(w io.Writer, colorEnabled bool) error
-
-// EmitterConfig contains command-scoped dependencies. A command constructs one
-// Emitter and reuses it for its success result or streamed pages.
-type EmitterConfig struct {
-	Out            io.Writer
-	ErrOut         io.Writer
-	CommandPath    string
-	Identity       string
-	ColorEnabled   bool
-	NoticeProvider NoticeProvider
-}
-
-// EmitOptions describes one result's wire representation.
-//
-// The format contract is explicit: JSON (including the empty default) uses an
-// Envelope; pretty, table, csv, and ndjson render naked business data. JQ takes
-// precedence over Format and filters the JSON Envelope. Raw affects only JSON
-// envelope encoding and jq's complex-value encoding.
-//
-// JQSafetyWarning preserves the legacy difference between RuntimeContext.emit
-// (false) and WriteSuccessEnvelope (true) until their callers are migrated.
-type EmitOptions struct {
-	Raw             bool
-	Meta            *Meta
-	Format          string
-	JQ              string
-	DryRun          bool
-	Pretty          PrettyRenderer
-	JQSafetyWarning bool
-}
-
-// StreamOptions describes one streamed page's wire representation. Streaming
-// carries page items directly, so it deliberately exposes only the fields that
-// affect a single page: the format and, for pretty, its renderer. It has no
-// OK/Meta/DryRun/JQ — an ok:false envelope, metadata, dry-run, and jq all need
-// the aggregated result, which the caller's pagination layer owns before it
-// streams pages.
-type StreamOptions struct {
-	Format string
-	Pretty PrettyRenderer
-}
-
-// Emitter owns all command-scoped output dependencies and pagination state.
-// It deliberately has no dependency on client or cmdutil.
-type Emitter struct {
-	out            io.Writer
-	errOut         io.Writer
-	commandPath    string
-	identity       string
-	colorEnabled   bool
-	noticeProvider NoticeProvider
-
-	streamFormat    string
-	streamFormatter *PaginatedFormatter
-}
-
-// NewEmitter constructs a command-scoped output emitter.
-func NewEmitter(config EmitterConfig) *Emitter {
-	errOut := config.ErrOut
-	if errOut == nil {
-		errOut = io.Discard
-	}
-	return &Emitter{
-		out:            config.Out,
-		errOut:         errOut,
-		commandPath:    config.CommandPath,
-		identity:       config.Identity,
-		colorEnabled:   config.ColorEnabled,
-		noticeProvider: config.NoticeProvider,
-	}
-}
-
-// Success scans and emits one command result by composing the package's leaf
-// primitives. JSON and jq use the standard envelope; pretty, table, csv, and
-// ndjson render the business value directly.
-func (e *Emitter) Success(data interface{}, opts EmitOptions) error {
-	if err := e.requireOutput(); err != nil {
-		return err
-	}
-
-	if opts.JQ != "" {
-		return e.emitEnvelope(data, true, opts)
-	}
-
-	switch opts.Format {
-	case "", "json":
-		return e.emitEnvelope(data, true, opts)
-	case "pretty":
-		return e.emitPretty(data, opts)
-	default:
-		return e.emitFormatted(data, opts.Format)
-	}
-}
-
-// PartialFailure emits a multi-status result whose envelope honestly reports
-// ok:false. It is the typed counterpart to Success for batch operations where
-// some items failed but the per-item outcomes are the primary stdout output.
-// Like the legacy OutPartialFailure it produces only the JSON/jq envelope; the
-// caller owns the non-zero exit signal, keeping the Emitter free of exit
-// semantics.
-func (e *Emitter) PartialFailure(data interface{}, opts EmitOptions) error {
-	if err := e.requireOutput(); err != nil {
-		return err
-	}
-	return e.emitEnvelope(data, false, opts)
-}
-
-// StreamPage scans and emits one page while retaining table/csv columns from
-// the first page. Streamed output carries page items directly, so it takes a
-// StreamOptions (format + optional pretty renderer) rather than the full
-// EmitOptions: ok/meta/dry-run/jq all need the aggregated result and are the
-// caller's pagination-layer responsibility, not a per-page concern. Excluding
-// jq from the type makes "jq requires aggregated output" a compile-time fact
-// instead of a runtime rejection.
-func (e *Emitter) StreamPage(data interface{}, opts StreamOptions) error {
-	if err := e.requireOutput(); err != nil {
-		return err
-	}
-
-	scanResult := ScanForSafety(e.commandPath, data, e.errOut)
-	if scanResult.Blocked {
-		return scanResult.BlockErr
-	}
-	if scanResult.Alert != nil {
-		if err := WriteAlertWarning(e.errOut, scanResult.Alert); err != nil {
-			return wrapOutputError("write", err)
-		}
-	}
-
-	if opts.Format == "pretty" {
-		if opts.Pretty == nil {
-			return errs.NewInternalError(errs.SubtypeUnknown,
-				"pretty output requires a renderer")
-		}
-		return e.emit(func(w io.Writer) error {
-			return opts.Pretty(w, e.colorEnabled)
-		})
-	}
-
-	format, known := ParseFormat(opts.Format)
-	if !known && e.streamFormatter == nil && e.errOut != nil {
-		fmt.Fprintf(e.errOut, "warning: unknown format %q, falling back to json\n", opts.Format)
-	}
-	if e.streamFormatter == nil {
-		e.streamFormat = opts.Format
-		e.streamFormatter = NewPaginatedFormatter(nil, format)
-	} else if opts.Format != e.streamFormat {
-		return errs.NewInternalError(errs.SubtypeUnknown,
-			"stream output format changed from %q to %q", e.streamFormat, opts.Format)
-	}
-
-	return e.emit(func(w io.Writer) error {
-		e.streamFormatter.W = w
-		return e.streamFormatter.WritePage(data)
-	})
-}
-
-func (e *Emitter) emitEnvelope(data interface{}, ok bool, opts EmitOptions) error {
-	scanResult := ScanForSafety(e.commandPath, data, e.errOut)
-	if scanResult.Blocked {
-		return scanResult.BlockErr
-	}
-
-	env := Envelope{
-		OK:       ok,
-		Identity: e.identity,
-		DryRun:   opts.DryRun,
-		Data:     data,
-		Meta:     opts.Meta,
-		Notice:   e.notice(),
-	}
-	if scanResult.Alert != nil {
-		env.ContentSafetyAlert = scanResult.Alert
-	}
-
-	if opts.JQ != "" {
-		if scanResult.Alert != nil && opts.JQSafetyWarning {
-			if err := WriteAlertWarning(e.errOut, scanResult.Alert); err != nil {
-				return wrapOutputError("write", err)
-			}
-		}
-		// Buffer the jq output manually so jq's own typed error (a validation
-		// error for a bad expression, an api error for a runtime failure) is
-		// returned unchanged; only a genuine stdout write failure is wrapped as
-		// an internal output error.
-		var buf bytes.Buffer
-		var jqErr error
-		if opts.Raw {
-			jqErr = JqFilterRaw(&buf, env, opts.JQ)
-		} else {
-			jqErr = JqFilter(&buf, env, opts.JQ)
-		}
-		if jqErr != nil {
-			return jqErr
-		}
-		if _, err := io.Copy(e.out, &buf); err != nil {
-			return wrapOutputError("write", err)
-		}
-		return nil
-	}
-
-	return e.emit(func(w io.Writer) error {
-		if opts.Raw {
-			enc := json.NewEncoder(w)
-			enc.SetEscapeHTML(false)
-			enc.SetIndent("", "  ")
-			return enc.Encode(env)
-		}
-		return WriteJSON(w, env)
-	})
-}
-
-func (e *Emitter) emitPretty(data interface{}, opts EmitOptions) error {
-	scanResult := ScanForSafety(e.commandPath, data, e.errOut)
-	if scanResult.Blocked {
-		return scanResult.BlockErr
-	}
-	if scanResult.Alert != nil {
-		if err := WriteAlertWarning(e.errOut, scanResult.Alert); err != nil {
-			return wrapOutputError("write", err)
-		}
-	}
-	if opts.Pretty != nil {
-		return e.emit(func(w io.Writer) error {
-			return opts.Pretty(w, e.colorEnabled)
-		})
-	}
-
-	// RuntimeContext.outFormat falls back through Out/OutRaw when no pretty
-	// renderer is supplied. Keep that second scan visible in the leaf contract
-	// until production callers are migrated and the legacy behavior is removed.
-	return e.emitEnvelope(data, true, opts)
-}
-
-func (e *Emitter) emitFormatted(data interface{}, rawFormat string) error {
-	scanResult := ScanForSafety(e.commandPath, data, e.errOut)
-	if scanResult.Blocked {
-		return scanResult.BlockErr
-	}
-	if scanResult.Alert != nil {
-		if err := WriteAlertWarning(e.errOut, scanResult.Alert); err != nil {
-			return wrapOutputError("write", err)
-		}
-	}
-
-	format, known := ParseFormat(rawFormat)
-	if !known && e.errOut != nil {
-		fmt.Fprintf(e.errOut, "warning: unknown format %q, falling back to json\n", rawFormat)
-	}
-	if format == FormatJSON {
-		return e.printLegacyDataJSON(data)
-	}
-	return e.emit(func(w io.Writer) error {
-		return WriteFormatted(w, data, format)
-	})
-}
-
-type emitterDataMap map[string]interface{}
-
-// printLegacyDataJSON matches FormatValue's JSON branch while sourcing notice
-// data from this Emitter instead of PrintJson's global PendingNotice hook.
-func (e *Emitter) printLegacyDataJSON(data interface{}) error {
-	// Normalise structs / named maps to plain generic types first, exactly as
-	// FormatValue does, so a struct or named-map payload still matches the map
-	// case below and keeps its injected _notice on the unknown-format fallback.
-	data = toGeneric(data)
-	if m, ok := data.(map[string]interface{}); ok {
-		if _, isEnvelope := m["ok"]; isEnvelope {
-			if notice := e.notice(); notice != nil {
-				m = maps.Clone(m)
-				m["_notice"] = notice
-			}
-		}
-		// The named map retains identical JSON bytes while preventing PrintJson
-		// from consulting its legacy global notice hook a second time.
-		return e.emit(func(w io.Writer) error {
-			return WriteJSON(w, emitterDataMap(m))
-		})
-	}
-	return e.emit(func(w io.Writer) error {
-		return WriteJSON(w, data)
-	})
-}
-
-func (e *Emitter) emit(render func(io.Writer) error) error {
-	var buf bytes.Buffer
-	if err := render(&buf); err != nil {
-		return wrapOutputError("render", err)
-	}
-	if _, err := io.Copy(e.out, &buf); err != nil {
-		return wrapOutputError("write", err)
-	}
-	return nil
-}
-
-func wrapOutputError(op string, err error) error {
-	return errs.NewInternalError(errs.SubtypeUnknown, "failed to %s command output", op).WithCause(err)
-}
-
-func (e *Emitter) notice() map[string]interface{} {
-	if e.noticeProvider == nil {
-		return nil
-	}
-	return e.noticeProvider()
-}
-
-func (e *Emitter) requireOutput() error {
-	if e == nil || e.out == nil {
-		return errs.NewInternalError(errs.SubtypeUnknown,
-			"success output writer is not configured")
-	}
-	return nil
-}

internal/output/emitter_contract_test.go

@@ -1,350 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package output_test
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"io"
-	"reflect"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	extcs "github.com/larksuite/cli/extension/contentsafety"
-	"github.com/larksuite/cli/internal/output"
-)
-
-type contractFailingWriter struct {
-	err error
-}
-
-func (w contractFailingWriter) Write([]byte) (int, error) {
-	return 0, w.err
-}
-
-type contractSafetyProvider struct {
-	alert *extcs.Alert
-}
-
-func (p *contractSafetyProvider) Name() string {
-	return "emitter-contract"
-}
-
-func (p *contractSafetyProvider) Scan(context.Context, extcs.ScanRequest) (*extcs.Alert, error) {
-	return p.alert, nil
-}
-
-func TestEmitterSuccessWritesAllBytes(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-	stdout := &bytes.Buffer{}
-	emitter := output.NewEmitter(output.EmitterConfig{
-		Out:         stdout,
-		ErrOut:      io.Discard,
-		CommandPath: "lark-cli fixture +emit",
-		Identity:    "bot",
-	})
-	data := map[string]interface{}{"id": "1"}
-
-	err := emitter.Success(data, output.EmitOptions{Format: "json"})
-	if err != nil {
-		t.Fatalf("Emitter.Success() error = %v", err)
-	}
-	want, marshalErr := json.MarshalIndent(output.Envelope{OK: true, Identity: "bot", Data: data}, "", "  ")
-	if marshalErr != nil {
-		t.Fatalf("marshal expected envelope: %v", marshalErr)
-	}
-	want = append(want, '\n')
-	if !bytes.Equal(stdout.Bytes(), want) {
-		t.Fatalf("stdout bytes = %q, want %q", stdout.Bytes(), want)
-	}
-}
-
-func TestEmitterMarshalFailureReturnsTypedErrorWithoutOutput(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-	stdout := &bytes.Buffer{}
-	emitter := output.NewEmitter(output.EmitterConfig{
-		Out:         stdout,
-		ErrOut:      io.Discard,
-		CommandPath: "lark-cli fixture +emit",
-	})
-
-	err := emitter.Success(map[string]interface{}{"unsupported": func() {}}, output.EmitOptions{Format: "json"})
-	if err == nil {
-		t.Fatal("Emitter.Success() error = nil, want marshal failure")
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok || problem.Category != errs.CategoryInternal {
-		t.Fatalf("Emitter.Success() problem = %#v, %v; want internal typed error", problem, ok)
-	}
-	var unsupported *json.UnsupportedTypeError
-	if !errors.As(err, &unsupported) {
-		t.Fatalf("Emitter.Success() error = %v, want json.UnsupportedTypeError cause", err)
-	}
-	if stdout.Len() != 0 {
-		t.Fatalf("Emitter.Success() stdout = %q, want empty", stdout.String())
-	}
-}
-
-func TestEmitterWriterFailurePreservesCause(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-	sentinel := errors.New("write failed")
-	emitter := output.NewEmitter(output.EmitterConfig{
-		Out:         contractFailingWriter{err: sentinel},
-		ErrOut:      io.Discard,
-		CommandPath: "lark-cli fixture +emit",
-	})
-
-	err := emitter.Success(map[string]interface{}{"id": "1"}, output.EmitOptions{Format: "json"})
-	if !errors.Is(err, sentinel) {
-		t.Fatalf("Emitter.Success() error = %v, want preserved writer cause", err)
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok || problem.Category != errs.CategoryInternal {
-		t.Fatalf("Emitter.Success() problem = %#v, %v; want internal typed error", problem, ok)
-	}
-}
-
-func TestEmitterPrettyRendererFailurePreservesCause(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-	sentinel := errors.New("pretty render failed")
-	stdout := &bytes.Buffer{}
-	emitter := output.NewEmitter(output.EmitterConfig{
-		Out:         stdout,
-		ErrOut:      io.Discard,
-		CommandPath: "lark-cli fixture +emit",
-	})
-
-	err := emitter.Success(map[string]interface{}{"id": "1"}, output.EmitOptions{
-		Format: "pretty",
-		Pretty: func(io.Writer, bool) error {
-			return sentinel
-		},
-	})
-	if !errors.Is(err, sentinel) {
-		t.Fatalf("Emitter.Success() error = %v, want preserved renderer cause", err)
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok || problem.Category != errs.CategoryInternal {
-		t.Fatalf("Emitter.Success() problem = %#v, %v; want internal typed error", problem, ok)
-	}
-	if stdout.Len() != 0 {
-		t.Fatalf("Emitter.Success() stdout = %q, want empty", stdout.String())
-	}
-}
-
-func TestEmitterAlertWarningFailurePreservesCause(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "warn")
-	extcs.Register(&contractSafetyProvider{alert: &extcs.Alert{
-		Provider:     "emitter-contract",
-		MatchedRules: []string{"fixture-rule"},
-	}})
-	t.Cleanup(func() { extcs.Register(nil) })
-	sentinel := errors.New("warning write failed")
-	stdout := &bytes.Buffer{}
-	emitter := output.NewEmitter(output.EmitterConfig{
-		Out:         stdout,
-		ErrOut:      contractFailingWriter{err: sentinel},
-		CommandPath: "lark-cli fixture +emit",
-	})
-
-	err := emitter.Success([]interface{}{map[string]interface{}{"id": "1"}}, output.EmitOptions{Format: "table"})
-	if !errors.Is(err, sentinel) {
-		t.Fatalf("Emitter.Success() error = %v, want preserved warning writer cause", err)
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok || problem.Category != errs.CategoryInternal {
-		t.Fatalf("Emitter.Success() problem = %#v, %v; want internal typed error", problem, ok)
-	}
-	if stdout.Len() != 0 {
-		t.Fatalf("Emitter.Success() stdout = %q, want empty", stdout.String())
-	}
-}
-
-func TestNewEmitterDefaultsNilErrOutToDiscard(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "warn")
-	extcs.Register(&contractSafetyProvider{alert: &extcs.Alert{
-		Provider:     "emitter-contract",
-		MatchedRules: []string{"fixture-rule"},
-	}})
-	t.Cleanup(func() { extcs.Register(nil) })
-	stdout := &bytes.Buffer{}
-	emitter := output.NewEmitter(output.EmitterConfig{
-		Out:         stdout,
-		CommandPath: "lark-cli fixture +emit",
-	})
-
-	if err := emitter.Success([]interface{}{map[string]interface{}{"id": "1"}}, output.EmitOptions{Format: "table"}); err != nil {
-		t.Fatalf("Emitter.Success() error = %v", err)
-	}
-	if stdout.Len() == 0 {
-		t.Fatal("Emitter.Success() stdout is empty")
-	}
-}
-
-func TestEmitterDoesNotMutateCallerMap(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-	data := map[string]interface{}{"ok": true, "value": "fixture"}
-	want := map[string]interface{}{"ok": true, "value": "fixture"}
-	emitter := output.NewEmitter(output.EmitterConfig{
-		Out:         &bytes.Buffer{},
-		ErrOut:      io.Discard,
-		CommandPath: "lark-cli fixture +emit",
-		NoticeProvider: func() map[string]interface{} {
-			return map[string]interface{}{"update": "available"}
-		},
-	})
-
-	if err := emitter.Success(data, output.EmitOptions{Format: "yaml"}); err != nil {
-		t.Fatalf("Emitter.Success() error = %v", err)
-	}
-	if !reflect.DeepEqual(data, want) {
-		t.Fatalf("caller map = %#v, want unchanged %#v", data, want)
-	}
-}
-
-func TestEmitterDoesNotOverwriteCallerNotice(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-	existing := map[string]interface{}{"source": "caller"}
-	data := map[string]interface{}{"ok": true, "_notice": existing}
-	stdout := &bytes.Buffer{}
-	emitter := output.NewEmitter(output.EmitterConfig{
-		Out:         stdout,
-		ErrOut:      io.Discard,
-		CommandPath: "lark-cli fixture +emit",
-		NoticeProvider: func() map[string]interface{} {
-			return map[string]interface{}{"source": "provider"}
-		},
-	})
-
-	if err := emitter.Success(data, output.EmitOptions{Format: "yaml"}); err != nil {
-		t.Fatalf("Emitter.Success() error = %v", err)
-	}
-	if got := data["_notice"]; !reflect.DeepEqual(got, existing) {
-		t.Fatalf("caller _notice = %#v, want unchanged %#v", got, existing)
-	}
-	var emitted map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &emitted); err != nil {
-		t.Fatalf("decode stdout: %v", err)
-	}
-	if got := emitted["_notice"]; !reflect.DeepEqual(got, map[string]interface{}{"source": "provider"}) {
-		t.Fatalf("emitted _notice = %#v, want provider notice", got)
-	}
-}
-
-func TestEmitterReadsNoticeProviderAtMostOncePerEmission(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-	calls := 0
-	emitter := output.NewEmitter(output.EmitterConfig{
-		Out:         &bytes.Buffer{},
-		ErrOut:      io.Discard,
-		CommandPath: "lark-cli fixture +emit",
-		NoticeProvider: func() map[string]interface{} {
-			calls++
-			return map[string]interface{}{"source": "provider"}
-		},
-	})
-
-	if err := emitter.Success(map[string]interface{}{"ok": true}, output.EmitOptions{Format: "yaml"}); err != nil {
-		t.Fatalf("Emitter.Success() error = %v", err)
-	}
-	if calls != 1 {
-		t.Fatalf("notice provider calls = %d, want 1", calls)
-	}
-}
-
-func TestEmitterRawJSONPropagatesWriteError(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-	sentinel := errors.New("write failed")
-	emitter := output.NewEmitter(output.EmitterConfig{
-		Out:         contractFailingWriter{err: sentinel},
-		ErrOut:      io.Discard,
-		CommandPath: "lark-cli fixture +emit",
-	})
-	err := emitter.Success(map[string]interface{}{"id": "1"}, output.EmitOptions{
-		Raw: true, Format: "json",
-	})
-	if !errors.Is(err, sentinel) {
-		t.Fatalf("Emitter.Success() error = %v, want preserved writer cause", err)
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok || problem.Category != errs.CategoryInternal {
-		t.Fatalf("Emitter.Success() problem = %#v, %v; want internal typed error", problem, ok)
-	}
-}
-
-func TestEmitterInvalidJQReturnsErrorWithoutStderr(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-	stderr := &bytes.Buffer{}
-	emitter := output.NewEmitter(output.EmitterConfig{
-		Out:         &bytes.Buffer{},
-		ErrOut:      stderr,
-		CommandPath: "lark-cli fixture +emit",
-	})
-	err := emitter.Success(map[string]interface{}{"id": "1"}, output.EmitOptions{
-		Format: "json",
-		JQ:     "this is not valid jq (((",
-	})
-	if err == nil {
-		t.Fatal("Success() with invalid jq = nil, want error")
-	}
-	if stderr.Len() != 0 {
-		t.Fatalf("Success() with invalid jq wrote stderr %q, want empty", stderr.String())
-	}
-}
-
-func TestEmitterJQRuntimeErrorPreservesTypedError(t *testing.T) {
-	// A valid expression that fails at runtime must surface jq's own typed error
-	// (an api error), not a wrapped internal output error, and must emit no
-	// partial stdout.
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-	stdout := &bytes.Buffer{}
-	emitter := output.NewEmitter(output.EmitterConfig{
-		Out:         stdout,
-		ErrOut:      io.Discard,
-		CommandPath: "lark-cli fixture +emit",
-	})
-	err := emitter.Success(map[string]interface{}{"id": "1"}, output.EmitOptions{
-		Format: "json",
-		JQ:     `error("boom")`,
-	})
-	if err == nil {
-		t.Fatal("Success() with a runtime jq error = nil, want error")
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok || problem.Category == errs.CategoryInternal {
-		t.Fatalf("Success() jq runtime error problem = %#v, %v; want jq's own typed error, not internal", problem, ok)
-	}
-	if !strings.Contains(err.Error(), "jq error") {
-		t.Fatalf("Success() jq runtime error = %v, want jq's own error message preserved", err)
-	}
-	if stdout.Len() != 0 {
-		t.Fatalf("Success() jq runtime error wrote stdout %q, want empty", stdout.String())
-	}
-}
-
-func TestEmitterUnknownFormatStructKeepsNotice(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-	type payload struct {
-		OK    bool   `json:"ok"`
-		Value string `json:"value"`
-	}
-	stdout := &bytes.Buffer{}
-	emitter := output.NewEmitter(output.EmitterConfig{
-		Out:         stdout,
-		ErrOut:      io.Discard,
-		CommandPath: "lark-cli fixture +emit",
-		NoticeProvider: func() map[string]interface{} {
-			return map[string]interface{}{"update": map[string]interface{}{"latest": "9.9.9"}}
-		},
-	})
-	if err := emitter.Success(payload{OK: true, Value: "fixture"}, output.EmitOptions{Format: "yaml"}); err != nil {
-		t.Fatalf("Success() error = %v", err)
-	}
-	if !strings.Contains(stdout.String(), "_notice") {
-		t.Fatalf("struct payload on unknown-format fallback dropped _notice:\n%s", stdout.String())
-	}
-}

internal/output/emitter_legacy_compat_test.go

@@ -1,827 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-// Legacy oracle fixtures are frozen at base SHA 4a56748bfa941ff0ee0bfec92e65acac427732b0.
-// Golden regeneration is allowed only from that base, never from the current system under test.
-
-package output_test
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"reflect"
-	"strings"
-	"testing"
-
-	"github.com/spf13/cobra"
-
-	"github.com/larksuite/cli/errs"
-	extcs "github.com/larksuite/cli/extension/contentsafety"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/output"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-type emitterCapture struct {
-	stdout string
-	stderr string
-	err    error
-}
-
-type emitterSafetyProvider struct {
-	alert *extcs.Alert
-	err   error
-}
-
-func (p *emitterSafetyProvider) Name() string { return "emitter-oracle" }
-
-func (p *emitterSafetyProvider) Scan(context.Context, extcs.ScanRequest) (*extcs.Alert, error) {
-	return p.alert, p.err
-}
-
-const (
-	runtimeContextLegacyGoldenPath       = "testdata/runtime_context_legacy.golden.json"
-	writeSuccessEnvelopeLegacyGoldenPath = "testdata/write_success_envelope_legacy.golden.json"
-)
-
-type runtimeContextOracleCase struct {
-	name        string
-	data        func() interface{}
-	raw         bool
-	ok          bool
-	meta        *output.Meta
-	jq          string
-	format      string
-	useFormat   bool
-	pretty      bool
-	notice      map[string]interface{}
-	safetyMode  string
-	safetyAlert *extcs.Alert
-	safetyErr   error
-}
-
-type runtimeContextLegacyGolden struct {
-	Cases map[string]emitterCaptureGolden `json:"cases"`
-}
-
-type writeSuccessEnvelopeOracleCase struct {
-	name        string
-	data        func() interface{}
-	dryRun      bool
-	jq          string
-	notice      map[string]interface{}
-	safetyMode  string
-	safetyAlert *extcs.Alert
-}
-
-type writeSuccessEnvelopeLegacyGolden struct {
-	Cases map[string]emitterCaptureGolden `json:"cases"`
-}
-
-type emitterCaptureGolden struct {
-	Stdout string              `json:"stdout"`
-	Stderr string              `json:"stderr"`
-	Error  *emitterErrorGolden `json:"error,omitempty"`
-}
-
-type emitterErrorGolden struct {
-	GoType   string          `json:"go_type"`
-	JSON     json.RawMessage `json:"json"`
-	Message  string          `json:"message"`
-	ExitCode int             `json:"exit_code"`
-}
-
-func TestEmitterMatchesRuntimeContextLegacyOracle(t *testing.T) {
-	previousNotice := output.PendingNotice
-	t.Cleanup(func() {
-		output.PendingNotice = previousNotice
-		extcs.Register(nil)
-	})
-
-	cases := []runtimeContextOracleCase{
-		{
-			name: "json_object",
-			data: func() interface{} {
-				return map[string]interface{}{"id": "1", "enabled": true}
-			},
-			ok: true,
-		},
-		{
-			name: "raw_json_preserves_html",
-			data: func() interface{} {
-				return map[string]interface{}{"html": "<p>a&b</p>"}
-			},
-			raw: true,
-			ok:  true,
-		},
-		{
-			name: "format_raw_json_preserves_html",
-			data: func() interface{} {
-				return map[string]interface{}{"html": "<p>a&b</p>"}
-			},
-			raw:       true,
-			ok:        true,
-			format:    "json",
-			useFormat: true,
-		},
-		{
-			name: "partial_failure_ok_false",
-			data: func() interface{} {
-				return map[string]interface{}{"succeeded": 1, "failed": 1}
-			},
-			ok: false,
-		},
-		{
-			name: "metadata",
-			data: func() interface{} {
-				return []interface{}{map[string]interface{}{"id": "1"}}
-			},
-			ok:   true,
-			meta: &output.Meta{Count: 1, Rollback: "lark-cli fixture rollback"},
-		},
-		{
-			name: "jq_scalar",
-			data: func() interface{} {
-				return map[string]interface{}{"name": "Alice", "age": 30}
-			},
-			ok: true,
-			jq: ".data.name",
-		},
-		{
-			name: "raw_jq_complex",
-			data: func() interface{} {
-				return map[string]interface{}{"document": map[string]interface{}{"html": "<p>a&b</p>"}}
-			},
-			raw: true,
-			ok:  true,
-			jq:  ".data.document",
-		},
-		{
-			name: "jq_invalid_expression",
-			data: func() interface{} {
-				return map[string]interface{}{"id": "1"}
-			},
-			ok: false,
-			jq: "invalid[",
-		},
-		{
-			name: "notice",
-			data: func() interface{} {
-				return map[string]interface{}{"id": "1"}
-			},
-			ok:     true,
-			notice: map[string]interface{}{"update": map[string]interface{}{"latest": "9.9.9"}},
-		},
-		{
-			name: "pretty",
-			data: func() interface{} {
-				return map[string]interface{}{"name": "Alice"}
-			},
-			ok:        true,
-			format:    "pretty",
-			useFormat: true,
-			pretty:    true,
-		},
-		{
-			name: "pretty_without_renderer",
-			data: func() interface{} {
-				return map[string]interface{}{"name": "Alice"}
-			},
-			ok:        true,
-			format:    "pretty",
-			useFormat: true,
-		},
-		{
-			name: "ndjson",
-			data: func() interface{} {
-				return map[string]interface{}{"items": []interface{}{
-					map[string]interface{}{"id": "1"},
-					map[string]interface{}{"id": "2"},
-				}}
-			},
-			ok:        true,
-			format:    "ndjson",
-			useFormat: true,
-		},
-		{
-			name: "table_with_safety_warning",
-			data: func() interface{} {
-				return []interface{}{map[string]interface{}{"id": "1", "name": "Alice"}}
-			},
-			ok:         true,
-			format:     "table",
-			useFormat:  true,
-			safetyMode: "warn",
-			safetyAlert: &extcs.Alert{
-				Provider:     "emitter-oracle",
-				MatchedRules: []string{"fixture-rule"},
-			},
-		},
-		{
-			name: "csv",
-			data: func() interface{} {
-				return []interface{}{
-					map[string]interface{}{"id": "1", "name": "Alice"},
-					map[string]interface{}{"id": "2", "name": "Bob"},
-				}
-			},
-			ok:        true,
-			format:    "csv",
-			useFormat: true,
-		},
-		{
-			name: "jq_safety_alert_without_stderr_warning",
-			data: func() interface{} {
-				return map[string]interface{}{"id": "1"}
-			},
-			ok:         true,
-			jq:         ".data.id",
-			safetyMode: "warn",
-			safetyAlert: &extcs.Alert{
-				Provider:     "emitter-oracle",
-				MatchedRules: []string{"fixture-rule"},
-			},
-		},
-		{
-			name: "scanner_error_fails_open",
-			data: func() interface{} {
-				return map[string]interface{}{"id": "1"}
-			},
-			ok:         true,
-			safetyMode: "warn",
-			safetyErr:  errors.New("scanner unavailable"),
-		},
-		{
-			name: "scanner_block",
-			data: func() interface{} {
-				return map[string]interface{}{"id": "blocked"}
-			},
-			ok:         false,
-			safetyMode: "block",
-			safetyAlert: &extcs.Alert{
-				Provider:     "emitter-oracle",
-				MatchedRules: []string{"fixture-rule"},
-			},
-		},
-		{
-			name: "unknown_format_data_envelope_notice",
-			data: func() interface{} {
-				return map[string]interface{}{"ok": true, "value": "fixture"}
-			},
-			ok:        true,
-			format:    "yaml",
-			useFormat: true,
-			notice:    map[string]interface{}{"skills": map[string]interface{}{"current": "1.0.0"}},
-		},
-	}
-
-	golden := loadRuntimeContextLegacyGolden(t)
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			mode := tc.safetyMode
-			if mode == "" {
-				mode = "off"
-			}
-			t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", mode)
-			extcs.Register(&emitterSafetyProvider{alert: tc.safetyAlert, err: tc.safetyErr})
-			t.Cleanup(func() { extcs.Register(nil) })
-
-			notice := tc.notice
-			output.PendingNotice = func() map[string]interface{} { return notice }
-
-			want, ok := golden.Cases[tc.name]
-			if !ok {
-				t.Fatalf("frozen golden case %q is missing", tc.name)
-			}
-
-			opts := runtimeOracleOptions{
-				raw:       tc.raw,
-				ok:        tc.ok,
-				meta:      tc.meta,
-				jq:        tc.jq,
-				format:    tc.format,
-				useFormat: tc.useFormat,
-				pretty:    tc.pretty,
-			}
-			current := runEmitterWithRuntimeContextContract(tc.data(), output.EmitterConfig{
-				CommandPath:    "lark-cli fixture +emit",
-				Identity:       "bot",
-				NoticeProvider: func() map[string]interface{} { return notice },
-			}, tc.ok, output.EmitOptions{
-				Raw:    tc.raw,
-				Meta:   tc.meta,
-				Format: tc.format,
-				JQ:     tc.jq,
-				Pretty: emitterPrettyRenderer(tc.pretty),
-			})
-
-			assertEmitterGolden(t, want, current)
-
-			integrated := runRuntimeContextOracle(t, tc.data(), opts)
-			assertEmitterGolden(t, want, integrated)
-			if tc.safetyMode == "block" {
-				var safetyErr *errs.ContentSafetyError
-				if !errors.As(current.err, &safetyErr) {
-					t.Fatalf("Emitter.Success() error = %T, want *errs.ContentSafetyError", current.err)
-				}
-			}
-		})
-	}
-
-	if len(golden.Cases) != len(cases) {
-		t.Fatalf("golden case count = %d, want %d", len(golden.Cases), len(cases))
-	}
-
-	jqFailure := golden.Cases["jq_invalid_expression"]
-	if !strings.HasPrefix(jqFailure.Stderr, "error: ") || !strings.HasSuffix(jqFailure.Stderr, "\n") {
-		t.Fatalf("invalid jq golden stderr = %q, want error line ending in newline", jqFailure.Stderr)
-	}
-	if jqFailure.Error == nil || jqFailure.Error.ExitCode != output.ExitValidation {
-		t.Fatalf("invalid jq golden exit = %#v, want %d", jqFailure.Error, output.ExitValidation)
-	}
-}
-
-func loadRuntimeContextLegacyGolden(t *testing.T) runtimeContextLegacyGolden {
-	t.Helper()
-	contents, err := os.ReadFile(runtimeContextLegacyGoldenPath)
-	if err != nil {
-		t.Fatalf("read RuntimeContext legacy golden: %v", err)
-	}
-	var golden runtimeContextLegacyGolden
-	if err := json.Unmarshal(contents, &golden); err != nil {
-		t.Fatalf("decode RuntimeContext legacy golden: %v", err)
-	}
-	return golden
-}
-
-func captureEmitterGolden(t *testing.T, capture emitterCapture) emitterCaptureGolden {
-	t.Helper()
-	golden := emitterCaptureGolden{Stdout: capture.stdout, Stderr: capture.stderr}
-	if capture.err == nil {
-		return golden
-	}
-	errorJSON, err := json.Marshal(capture.err)
-	if err != nil {
-		t.Fatalf("marshal captured error %T: %v", capture.err, err)
-	}
-	golden.Error = &emitterErrorGolden{
-		GoType:   fmt.Sprintf("%T", capture.err),
-		JSON:     errorJSON,
-		Message:  capture.err.Error(),
-		ExitCode: output.ExitCodeOf(capture.err),
-	}
-	return golden
-}
-
-type runtimeOracleOptions struct {
-	raw       bool
-	ok        bool
-	meta      *output.Meta
-	jq        string
-	format    string
-	useFormat bool
-	pretty    bool
-}
-
-func runRuntimeContextOracle(t *testing.T, data interface{}, opts runtimeOracleOptions) emitterCapture {
-	t.Helper()
-	stdout := &bytes.Buffer{}
-	stderr := &bytes.Buffer{}
-	parent := &cobra.Command{Use: "lark-cli"}
-	cmd := &cobra.Command{Use: "fixture"}
-	leaf := &cobra.Command{Use: "+emit"}
-	parent.AddCommand(cmd)
-	cmd.AddCommand(leaf)
-
-	factory := &cmdutil.Factory{IOStreams: &cmdutil.IOStreams{Out: stdout, ErrOut: stderr}}
-	runtime := common.TestNewRuntimeContextForAPI(
-		context.Background(), leaf, &core.CliConfig{Brand: core.BrandFeishu}, factory, core.AsBot,
-	)
-	runtime.Format = opts.format
-	runtime.JqExpr = opts.jq
-
-	pretty := func(w io.Writer) {
-		fmt.Fprintln(w, "pretty:fixture")
-	}
-	if !opts.pretty {
-		pretty = nil
-	}
-
-	var err error
-	switch {
-	case opts.useFormat && opts.raw:
-		runtime.OutFormatRaw(data, opts.meta, pretty)
-	case opts.useFormat:
-		runtime.OutFormat(data, opts.meta, pretty)
-	case !opts.ok:
-		err = runtime.OutPartialFailure(data, opts.meta)
-	case opts.raw:
-		runtime.OutRaw(data, opts.meta)
-	default:
-		runtime.Out(data, opts.meta)
-	}
-
-	return emitterCapture{stdout: stdout.String(), stderr: stderr.String(), err: err}
-}
-
-func runEmitterSuccess(data interface{}, config output.EmitterConfig, ok bool, opts output.EmitOptions) emitterCapture {
-	stdout := &bytes.Buffer{}
-	stderr := &bytes.Buffer{}
-	config.Out = stdout
-	config.ErrOut = stderr
-	emitter := output.NewEmitter(config)
-	var err error
-	if ok {
-		err = emitter.Success(data, opts)
-	} else {
-		err = emitter.PartialFailure(data, opts)
-	}
-	return emitterCapture{stdout: stdout.String(), stderr: stderr.String(), err: err}
-}
-
-func runEmitterWithRuntimeContextContract(data interface{}, config output.EmitterConfig, ok bool, opts output.EmitOptions) emitterCapture {
-	capture := runEmitterSuccess(data, config, ok, opts)
-	if capture.err != nil {
-		var safetyErr *errs.ContentSafetyError
-		if errors.As(capture.err, &safetyErr) {
-			return capture
-		}
-		if opts.JQ != "" {
-			capture.stderr += fmt.Sprintf("error: %v\n", capture.err)
-			return capture
-		}
-		capture.err = nil
-	}
-	if !ok {
-		capture.err = output.PartialFailure(output.ExitAPI)
-	}
-	return capture
-}
-
-func emitterPrettyRenderer(enabled bool) output.PrettyRenderer {
-	if !enabled {
-		return nil
-	}
-	return func(w io.Writer, _ bool) error {
-		_, err := fmt.Fprintln(w, "pretty:fixture")
-		return err
-	}
-}
-
-func TestEmitterMatchesWriteSuccessEnvelopeLegacyOracle(t *testing.T) {
-	previousNotice := output.PendingNotice
-	t.Cleanup(func() {
-		output.PendingNotice = previousNotice
-		extcs.Register(nil)
-	})
-
-	cases := []writeSuccessEnvelopeOracleCase{
-		{
-			name: "json",
-			data: func() interface{} { return map[string]interface{}{"id": "1"} },
-		},
-		{
-			name:   "dry_run",
-			data:   func() interface{} { return map[string]interface{}{"api": []interface{}{}} },
-			dryRun: true,
-		},
-		{
-			name: "jq",
-			data: func() interface{} { return map[string]interface{}{"id": "1"} },
-			jq:   ".data.id",
-		},
-		{
-			name:   "notice",
-			data:   func() interface{} { return map[string]interface{}{"id": "1"} },
-			notice: map[string]interface{}{"update": map[string]interface{}{"latest": "9.9.9"}},
-		},
-		{
-			name:       "jq_safety_warning",
-			data:       func() interface{} { return map[string]interface{}{"id": "1"} },
-			jq:         ".data.id",
-			safetyMode: "warn",
-			safetyAlert: &extcs.Alert{
-				Provider:     "emitter-oracle",
-				MatchedRules: []string{"fixture-rule"},
-			},
-		},
-		{
-			name:       "scanner_block",
-			data:       func() interface{} { return map[string]interface{}{"id": "blocked"} },
-			safetyMode: "block",
-			safetyAlert: &extcs.Alert{
-				Provider:     "emitter-oracle",
-				MatchedRules: []string{"fixture-rule"},
-			},
-		},
-	}
-	golden := loadWriteSuccessEnvelopeLegacyGolden(t)
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			mode := tc.safetyMode
-			if mode == "" {
-				mode = "off"
-			}
-			t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", mode)
-			extcs.Register(&emitterSafetyProvider{alert: tc.safetyAlert})
-			t.Cleanup(func() { extcs.Register(nil) })
-			notice := tc.notice
-			output.PendingNotice = func() map[string]interface{} { return notice }
-
-			want, ok := golden.Cases[tc.name]
-			if !ok {
-				t.Fatalf("frozen golden case %q is missing", tc.name)
-			}
-
-			current := runEmitterSuccess(tc.data(), output.EmitterConfig{
-				CommandPath:    "lark-cli fixture +emit",
-				Identity:       "bot",
-				NoticeProvider: func() map[string]interface{} { return notice },
-			}, true, output.EmitOptions{
-				Format:          "",
-				Raw:             false,
-				JQ:              tc.jq,
-				DryRun:          tc.dryRun,
-				JQSafetyWarning: true,
-			})
-			assertEmitterGolden(t, want, current)
-
-			integrated := runWriteSuccessEnvelopeOracle(tc.data(), tc.dryRun, tc.jq)
-			assertEmitterGolden(t, want, integrated)
-		})
-	}
-
-	if len(golden.Cases) != len(cases) {
-		t.Fatalf("golden case count = %d, want %d", len(golden.Cases), len(cases))
-	}
-}
-
-func loadWriteSuccessEnvelopeLegacyGolden(t *testing.T) writeSuccessEnvelopeLegacyGolden {
-	t.Helper()
-	contents, err := os.ReadFile(writeSuccessEnvelopeLegacyGoldenPath)
-	if err != nil {
-		t.Fatalf("read WriteSuccessEnvelope legacy golden: %v", err)
-	}
-	var golden writeSuccessEnvelopeLegacyGolden
-	if err := json.Unmarshal(contents, &golden); err != nil {
-		t.Fatalf("decode WriteSuccessEnvelope legacy golden: %v", err)
-	}
-	return golden
-}
-
-func runWriteSuccessEnvelopeOracle(data interface{}, dryRun bool, jq string) emitterCapture {
-	stdout := &bytes.Buffer{}
-	stderr := &bytes.Buffer{}
-	err := output.WriteSuccessEnvelope(data, output.SuccessEnvelopeOptions{
-		CommandPath: "lark-cli fixture +emit",
-		Identity:    "bot",
-		DryRun:      dryRun,
-		JqExpr:      jq,
-		Out:         stdout,
-		ErrOut:      stderr,
-	})
-	return emitterCapture{stdout: stdout.String(), stderr: stderr.String(), err: err}
-}
-
-func TestEmitterStreamPageMatchesPaginationLegacyOracle(t *testing.T) {
-	t.Cleanup(func() { extcs.Register(nil) })
-
-	type oracleCase struct {
-		name        string
-		format      output.Format
-		safetyMode  string
-		safetyAlert *extcs.Alert
-	}
-	cases := []oracleCase{
-		{name: "ndjson", format: output.FormatNDJSON},
-		{name: "table", format: output.FormatTable},
-		{name: "csv", format: output.FormatCSV},
-		{
-			name:       "warn",
-			format:     output.FormatNDJSON,
-			safetyMode: "warn",
-			safetyAlert: &extcs.Alert{
-				Provider:     "emitter-oracle",
-				MatchedRules: []string{"fixture-rule"},
-			},
-		},
-		{
-			name:       "block",
-			format:     output.FormatTable,
-			safetyMode: "block",
-			safetyAlert: &extcs.Alert{
-				Provider:     "emitter-oracle",
-				MatchedRules: []string{"fixture-rule"},
-			},
-		},
-	}
-
-	pages := []interface{}{
-		[]interface{}{map[string]interface{}{"id": "1", "name": "Alice"}},
-		[]interface{}{map[string]interface{}{"id": "2", "name": "Bob", "ignored": true}},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			mode := tc.safetyMode
-			if mode == "" {
-				mode = "off"
-			}
-			t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", mode)
-			extcs.Register(&emitterSafetyProvider{alert: tc.safetyAlert})
-			t.Cleanup(func() { extcs.Register(nil) })
-
-			legacy := runPaginationOracle(pages, tc.format)
-			current := runEmitterStreamPages(pages, tc.format.String())
-
-			assertEmitterBytes(t, legacy, current)
-			assertEquivalentError(t, legacy.err, current.err)
-		})
-	}
-}
-
-func runPaginationOracle(pages []interface{}, format output.Format) emitterCapture {
-	stdout := &bytes.Buffer{}
-	stderr := &bytes.Buffer{}
-	formatter := output.NewPaginatedFormatter(stdout, format)
-	var emitErr error
-	for _, page := range pages {
-		scanResult := output.ScanForSafety("lark-cli fixture +emit", page, stderr)
-		if scanResult.Blocked {
-			emitErr = scanResult.BlockErr
-			break
-		}
-		if scanResult.Alert != nil {
-			output.WriteAlertWarning(stderr, scanResult.Alert)
-		}
-		formatter.FormatPage(page)
-	}
-	return emitterCapture{stdout: stdout.String(), stderr: stderr.String(), err: emitErr}
-}
-
-func runEmitterStreamPages(pages []interface{}, format string) emitterCapture {
-	stdout := &bytes.Buffer{}
-	stderr := &bytes.Buffer{}
-	emitter := output.NewEmitter(output.EmitterConfig{
-		Out:         stdout,
-		ErrOut:      stderr,
-		CommandPath: "lark-cli fixture +emit",
-		Identity:    "bot",
-	})
-	var emitErr error
-	for _, page := range pages {
-		if emitErr = emitter.StreamPage(page, output.StreamOptions{Format: format}); emitErr != nil {
-			break
-		}
-	}
-	return emitterCapture{stdout: stdout.String(), stderr: stderr.String(), err: emitErr}
-}
-
-func TestEmitterCapturesNoticeAndColorDependencies(t *testing.T) {
-	previousNotice := output.PendingNotice
-	output.PendingNotice = func() map[string]interface{} {
-		return map[string]interface{}{"source": "global"}
-	}
-	t.Cleanup(func() { output.PendingNotice = previousNotice })
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-
-	stdout := &bytes.Buffer{}
-	stderr := &bytes.Buffer{}
-	colorSeen := false
-	emitter := output.NewEmitter(output.EmitterConfig{
-		Out:          stdout,
-		ErrOut:       stderr,
-		CommandPath:  "lark-cli fixture +emit",
-		Identity:     "bot",
-		ColorEnabled: true,
-		NoticeProvider: func() map[string]interface{} {
-			return map[string]interface{}{"source": "captured"}
-		},
-	})
-	if err := emitter.Success(map[string]interface{}{"id": "1"}, output.EmitOptions{Format: "json"}); err != nil {
-		t.Fatalf("Emitter.Success() error = %v", err)
-	}
-	if strings.Contains(stdout.String(), "global") || !strings.Contains(stdout.String(), "captured") {
-		t.Fatalf("notice source was not captured by Emitter:\n%s", stdout.String())
-	}
-
-	stdout.Reset()
-	if err := emitter.Success(map[string]interface{}{"id": "1"}, output.EmitOptions{Format: "pretty",
-		Pretty: func(w io.Writer, colorEnabled bool) error {
-			colorSeen = colorEnabled
-			_, err := fmt.Fprintln(w, "pretty")
-			return err
-		},
-	}); err != nil {
-		t.Fatalf("Emitter.Success(pretty) error = %v", err)
-	}
-	if !colorSeen {
-		t.Fatal("PrettyRenderer did not receive captured ColorEnabled value")
-	}
-
-	stdout.Reset()
-	if err := emitter.Success(map[string]interface{}{"ok": true, "id": "1"}, output.EmitOptions{Format: "yaml"}); err != nil {
-		t.Fatalf("Emitter.Success(unknown format) error = %v", err)
-	}
-	if strings.Contains(stdout.String(), "global") || !strings.Contains(stdout.String(), "captured") {
-		t.Fatalf("legacy JSON fallback consulted global notice:\n%s", stdout.String())
-	}
-}
-
-type failingEmitterWriter struct {
-	err error
-}
-
-func (w failingEmitterWriter) Write([]byte) (int, error) { return 0, w.err }
-
-func TestEmitterPropagatesOutputError(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-	sentinel := errors.New("write failed")
-	emitter := output.NewEmitter(output.EmitterConfig{
-		Out:         failingEmitterWriter{err: sentinel},
-		ErrOut:      io.Discard,
-		CommandPath: "lark-cli fixture +emit",
-	})
-	err := emitter.Success(map[string]interface{}{"id": "1"}, output.EmitOptions{
-		Raw: true, Format: "json",
-		JQ: ".data",
-	})
-	if !errors.Is(err, sentinel) {
-		t.Fatalf("Emitter.Success() error = %v, want preserved writer cause", err)
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok || problem.Category != errs.CategoryInternal {
-		t.Fatalf("Emitter.Success() problem = %#v, %v; want internal typed error", problem, ok)
-	}
-}
-
-func assertEmitterBytes(t *testing.T, legacy, current emitterCapture) {
-	t.Helper()
-	if legacy.stdout != current.stdout {
-		t.Fatalf("stdout byte mismatch\nlegacy (%d bytes):\n%q\nEmitter (%d bytes):\n%q",
-			len(legacy.stdout), legacy.stdout, len(current.stdout), current.stdout)
-	}
-	if legacy.stderr != current.stderr {
-		t.Fatalf("stderr byte mismatch\nlegacy (%d bytes):\n%q\nEmitter (%d bytes):\n%q",
-			len(legacy.stderr), legacy.stderr, len(current.stderr), current.stderr)
-	}
-}
-
-func assertEmitterGolden(t *testing.T, want emitterCaptureGolden, current emitterCapture) {
-	t.Helper()
-	if want.Stdout != current.stdout {
-		t.Fatalf("stdout byte mismatch\ngolden (%d bytes):\n%q\ncurrent (%d bytes):\n%q",
-			len(want.Stdout), want.Stdout, len(current.stdout), current.stdout)
-	}
-	if want.Stderr != current.stderr {
-		t.Fatalf("stderr byte mismatch\ngolden (%d bytes):\n%q\ncurrent (%d bytes):\n%q",
-			len(want.Stderr), want.Stderr, len(current.stderr), current.stderr)
-	}
-	got := captureEmitterGolden(t, current)
-	if (want.Error == nil) != (got.Error == nil) {
-		t.Fatalf("error presence mismatch: golden=%#v current=%#v", want.Error, got.Error)
-	}
-	if want.Error == nil {
-		return
-	}
-	if want.Error.GoType != got.Error.GoType || want.Error.Message != got.Error.Message || want.Error.ExitCode != got.Error.ExitCode {
-		t.Fatalf("error mismatch:\ngolden: %#v\ncurrent: %#v", want.Error, got.Error)
-	}
-	var wantJSON interface{}
-	if err := json.Unmarshal(want.Error.JSON, &wantJSON); err != nil {
-		t.Fatalf("decode golden error JSON: %v", err)
-	}
-	var gotJSON interface{}
-	if err := json.Unmarshal(got.Error.JSON, &gotJSON); err != nil {
-		t.Fatalf("decode current error JSON: %v", err)
-	}
-	if !reflect.DeepEqual(wantJSON, gotJSON) {
-		t.Fatalf("error JSON mismatch:\ngolden: %s\ncurrent: %s", want.Error.JSON, got.Error.JSON)
-	}
-}
-
-func assertEquivalentError(t *testing.T, legacy, current error) {
-	t.Helper()
-	if (legacy == nil) != (current == nil) {
-		t.Fatalf("error presence mismatch: legacy=%v Emitter=%v", legacy, current)
-	}
-	if legacy == nil {
-		return
-	}
-	legacyProblem, legacyOK := errs.ProblemOf(legacy)
-	currentProblem, currentOK := errs.ProblemOf(current)
-	if legacyOK != currentOK {
-		t.Fatalf("typed error mismatch: legacy=%T Emitter=%T", legacy, current)
-	}
-	if legacyOK && !reflect.DeepEqual(legacyProblem, currentProblem) {
-		t.Fatalf("problem mismatch:\nlegacy: %#v\nEmitter: %#v", legacyProblem, currentProblem)
-	}
-}

internal/output/envelope_success.go

@@ -34,17 +34,27 @@ func SuccessEnvelopeData(result interface{}) interface{} {
 // JSON output carries content-safety alerts inside the envelope. When jq is
 // applied, the alert may be filtered away, so warn mode also writes stderr.
 func WriteSuccessEnvelope(data interface{}, opts SuccessEnvelopeOptions) error {
-	return NewEmitter(EmitterConfig{
-		Out:            opts.Out,
-		ErrOut:         opts.ErrOut,
-		CommandPath:    opts.CommandPath,
-		Identity:       opts.Identity,
-		NoticeProvider: GetNotice,
-	}).Success(data, EmitOptions{
-		Format:          "",
-		Raw:             false,
-		JQ:              opts.JqExpr,
-		DryRun:          opts.DryRun,
-		JQSafetyWarning: true,
-	})
+	scanResult := ScanForSafety(opts.CommandPath, data, opts.ErrOut)
+	if scanResult.Blocked {
+		return scanResult.BlockErr
+	}
+
+	env := Envelope{
+		OK:       true,
+		Identity: opts.Identity,
+		DryRun:   opts.DryRun,
+		Data:     data,
+		Notice:   GetNotice(),
+	}
+	if scanResult.Alert != nil {
+		env.ContentSafetyAlert = scanResult.Alert
+	}
+	if opts.JqExpr != "" {
+		if scanResult.Alert != nil && opts.ErrOut != nil {
+			WriteAlertWarning(opts.ErrOut, scanResult.Alert)
+		}
+		return JqFilter(opts.Out, env, opts.JqExpr)
+	}
+	PrintJson(opts.Out, env)
+	return nil
 }

internal/output/format.go

@@ -101,44 +101,34 @@ func ExtractItems(data interface{}) []interface{} {
 
 // FormatValue formats a single response and writes it to w.
 func FormatValue(w io.Writer, data interface{}, format Format) {
-	err := WriteFormatted(w, data, format)
-	switch {
-	case err == nil:
-		return
-	case isOutputMarshalError(err) && format == FormatNDJSON:
-		legacyStderrf("ndjson marshal error: %v\n", err)
-	case isOutputMarshalError(err):
-		legacyStderrf("json marshal error: %v\n", err)
-	}
-}
-
-// WriteFormatted formats a single response and returns marshal or write errors.
-func WriteFormatted(w io.Writer, data interface{}, format Format) error {
 	data = toGeneric(data)
 	switch format {
 	case FormatNDJSON:
 		items := ExtractItems(data)
 		if items != nil {
-			return WriteNDJSON(w, items)
+			PrintNdjson(w, items)
+		} else {
+			PrintNdjson(w, data)
 		}
-		return WriteNDJSON(w, data)
 
 	case FormatTable:
 		items := ExtractItems(data)
 		if items != nil {
-			return WriteTable(w, items)
+			FormatAsTable(w, items)
+		} else {
+			FormatAsTable(w, data)
 		}
-		return WriteTable(w, data)
 
 	case FormatCSV:
 		items := ExtractItems(data)
 		if items != nil {
-			return WriteCSV(w, items)
+			FormatAsCSV(w, items)
+		} else {
+			FormatAsCSV(w, data)
 		}
-		return WriteCSV(w, data)
 
 	default: // FormatJSON
-		return WriteJSON(w, data)
+		PrintJson(w, data)
 	}
 }
 
@@ -158,63 +148,49 @@ func NewPaginatedFormatter(w io.Writer, format Format) *PaginatedFormatter {
 
 // FormatPage formats one page of items.
 func (pf *PaginatedFormatter) FormatPage(data interface{}) {
-	err := pf.WritePage(data)
-	if isOutputMarshalError(err) && (pf.Format == FormatJSON || pf.Format == FormatNDJSON) {
-		legacyStderrf("ndjson marshal error: %v\n", err)
-	}
-}
-
-// WritePage formats one page of items and returns marshal or write errors.
-func (pf *PaginatedFormatter) WritePage(data interface{}) error {
 	switch pf.Format {
 	case FormatJSON, FormatNDJSON:
 		if arr, ok := data.([]interface{}); ok {
-			return WriteNDJSON(pf.W, arr)
+			PrintNdjson(pf.W, arr)
+		} else {
+			PrintNdjson(pf.W, data)
 		}
-		return WriteNDJSON(pf.W, data)
 
 	case FormatTable:
-		return pf.formatStructuredPage(data, func(w io.Writer, rows []map[string]string, cols []string, isFirst bool) error {
+		pf.formatStructuredPage(data, func(w io.Writer, rows []map[string]string, cols []string, isFirst bool) {
 			widths := computeColumnWidths(rows, cols)
 			if isFirst {
-				if err := writeHeader(w, cols, widths); err != nil {
-					return err
-				}
+				writeHeader(w, cols, widths)
 			}
 			for _, row := range rows {
-				if err := writeRow(w, row, cols, widths); err != nil {
-					return err
-				}
+				writeRow(w, row, cols, widths)
 			}
-			return nil
 		})
 
 	case FormatCSV:
-		return pf.formatStructuredPage(data, func(w io.Writer, rows []map[string]string, cols []string, isFirst bool) error {
-			return writeCSVRows(w, rows, cols, isFirst)
+		pf.formatStructuredPage(data, func(w io.Writer, rows []map[string]string, cols []string, isFirst bool) {
+			writeCSVRows(w, rows, cols, isFirst)
 		})
 	}
-	return nil
 }
 
 // formatStructuredPage handles column-locking logic shared by table and csv.
-func (pf *PaginatedFormatter) formatStructuredPage(data interface{}, emit func(io.Writer, []map[string]string, []string, bool) error) error {
+func (pf *PaginatedFormatter) formatStructuredPage(data interface{}, emit func(io.Writer, []map[string]string, []string, bool)) {
 	rows, pageCols, isList := prepareRows(data)
 	if len(rows) == 0 {
 		if pf.isFirstPage && isList {
-			_, err := fmt.Fprintln(pf.W, "(empty)")
-			return err
+			fmt.Fprintln(pf.W, "(empty)")
 		}
-		return nil
+		return
 	}
 
 	if pf.isFirstPage {
 		// Lock columns from first page
 		pf.cols = pageCols
 		pf.isFirstPage = false
-		return emit(pf.W, rows, pf.cols, true)
+		emit(pf.W, rows, pf.cols, true)
 	} else {
 		// Reuse first page's columns — missing keys become empty, extra keys ignored
-		return emit(pf.W, rows, pf.cols, false)
+		emit(pf.W, rows, pf.cols, false)
 	}
 }

internal/output/print.go

@@ -5,7 +5,6 @@ package output
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -16,44 +15,12 @@ import (
 // PrintJson prints data as formatted JSON to w.
 func PrintJson(w io.Writer, data interface{}) {
 	injectNotice(data)
-	if err := WriteJSON(w, data); isOutputMarshalError(err) {
-		legacyStderrf("json marshal error: %v\n", err)
-	}
-}
-
-type outputMarshalError struct {
-	err error
-}
-
-func (e *outputMarshalError) Error() string {
-	return e.err.Error()
-}
-
-func (e *outputMarshalError) Unwrap() error {
-	return e.err
-}
-
-func isOutputMarshalError(err error) bool {
-	var marshalErr *outputMarshalError
-	return errors.As(err, &marshalErr)
-}
-
-// legacyStderrf reports a leaf-formatter marshal/format failure on os.Stderr,
-// preserving the pre-Emitter behavior for direct (unmigrated) callers of the
-// Print*/FormatAs* wrappers. The Emitter never uses this — it returns typed
-// errors instead. Removed once the remaining direct callers migrate.
-func legacyStderrf(format string, args ...interface{}) {
-	fmt.Fprintf(os.Stderr, format, args...) //nolint:forbidigo // legacy leaf-formatter stderr; removed in the output-ownership follow-up
-}
-
-// WriteJSON writes data as formatted JSON to w and returns marshal or write errors.
-func WriteJSON(w io.Writer, data interface{}) error {
 	b, err := json.MarshalIndent(data, "", "  ")
 	if err != nil {
-		return &outputMarshalError{err: err}
+		fmt.Fprintf(os.Stderr, "json marshal error: %v\n", err)
+		return
 	}
-	_, err = fmt.Fprintln(w, string(b))
-	return err
+	fmt.Fprintln(w, string(b))
 }
 
 // injectNotice adds a "_notice" field into CLI envelope maps.
@@ -83,38 +50,21 @@ func injectNotice(data interface{}) {
 
 // PrintNdjson prints data as NDJSON (Newline Delimited JSON) to w.
 func PrintNdjson(w io.Writer, data interface{}) {
-	if arr, ok := data.([]interface{}); ok {
-		for _, item := range arr {
-			if err := WriteNDJSON(w, item); isOutputMarshalError(err) {
-				legacyStderrf("ndjson marshal error: %v\n", err)
-			}
-		}
-		return
-	}
-	if err := WriteNDJSON(w, data); isOutputMarshalError(err) {
-		legacyStderrf("ndjson marshal error: %v\n", err)
-	}
-}
-
-// WriteNDJSON writes data as NDJSON and returns marshal or write errors.
-func WriteNDJSON(w io.Writer, data interface{}) error {
-	emit := func(item interface{}) error {
+	emit := func(item interface{}) {
 		b, err := json.Marshal(item)
 		if err != nil {
-			return &outputMarshalError{err: err}
+			fmt.Fprintf(os.Stderr, "ndjson marshal error: %v\n", err)
+			return
 		}
-		_, err = fmt.Fprintln(w, string(b))
-		return err
+		fmt.Fprintln(w, string(b))
 	}
 	if arr, ok := data.([]interface{}); ok {
 		for _, item := range arr {
-			if err := emit(item); err != nil {
-				return err
-			}
+			emit(item)
 		}
-		return nil
+	} else {
+		emit(data)
 	}
-	return emit(data)
 }
 
 func cellStr(val interface{}) string {

internal/output/table.go

@@ -16,69 +16,50 @@ const maxColWidth = 100
 //   - map[string]interface{} (single object) → key-value two-column table
 //   - empty array → "(empty)"
 func FormatAsTable(w io.Writer, data interface{}) {
-	if err := WriteTable(w, data); isOutputMarshalError(err) {
-		legacyStderrf("json marshal error: %v\n", err)
-	}
-}
-
-// WriteTable formats data as a table and returns marshal or write errors.
-func WriteTable(w io.Writer, data interface{}) error {
-	return WriteTablePaginated(w, data, true)
+	FormatAsTablePaginated(w, data, true)
 }
 
 // FormatAsTablePaginated formats data as a table with pagination awareness.
 // When isFirstPage is true, outputs the header; otherwise only data rows.
 func FormatAsTablePaginated(w io.Writer, data interface{}, isFirstPage bool) {
-	if err := WriteTablePaginated(w, data, isFirstPage); isOutputMarshalError(err) {
-		legacyStderrf("json marshal error: %v\n", err)
-	}
-}
-
-// WriteTablePaginated formats data as a table and returns marshal or write errors.
-func WriteTablePaginated(w io.Writer, data interface{}, isFirstPage bool) error {
 	rows, cols, isList := prepareRows(data)
 	if cols == nil {
 		if isList {
-			_, err := fmt.Fprintln(w, "(empty)")
-			return err
+			fmt.Fprintln(w, "(empty)")
 		} else {
 			// Not a list and not an object — print as JSON fallback
-			return WriteJSON(w, data)
+			PrintJson(w, data)
 		}
+		return
 	}
 
 	if len(rows) == 0 {
 		if isFirstPage {
-			_, err := fmt.Fprintln(w, "(empty)")
-			return err
+			fmt.Fprintln(w, "(empty)")
 		}
-		return nil
+		return
 	}
 
 	if !isList {
 		// Single object: key-value two-column format
-		return formatKeyValueTable(w, rows[0], cols)
+		formatKeyValueTable(w, rows[0], cols)
+		return
 	}
 
 	// Calculate column widths (clamped to maxColWidth)
 	widths := computeColumnWidths(rows, cols)
 
 	if isFirstPage {
-		if err := writeHeader(w, cols, widths); err != nil {
-			return err
-		}
+		writeHeader(w, cols, widths)
 	}
 
 	for _, row := range rows {
-		if err := writeRow(w, row, cols, widths); err != nil {
-			return err
-		}
+		writeRow(w, row, cols, widths)
 	}
-	return nil
 }
 
 // formatKeyValueTable renders a single object as a two-column key-value table.
-func formatKeyValueTable(w io.Writer, row map[string]string, cols []string) error {
+func formatKeyValueTable(w io.Writer, row map[string]string, cols []string) {
 	maxKeyWidth := 0
 	for _, col := range cols {
 		kw := stringWidth(col)
@@ -90,11 +71,8 @@ func formatKeyValueTable(w io.Writer, row map[string]string, cols []string) erro
 	for _, col := range cols {
 		val := row[col]
 		val = truncateToWidth(val, maxColWidth)
-		if _, err := fmt.Fprintf(w, "%s  %s\n", padToWidth(col, maxKeyWidth), val); err != nil {
-			return err
-		}
+		fmt.Fprintf(w, "%s  %s\n", padToWidth(col, maxKeyWidth), val)
 	}
-	return nil
 }
 
 // computeColumnWidths returns display widths for each column, clamped to maxColWidth.
@@ -121,29 +99,25 @@ func computeColumnWidths(rows []map[string]string, cols []string) []int {
 }
 
 // writeHeader writes the header row and separator line.
-func writeHeader(w io.Writer, cols []string, widths []int) error {
+func writeHeader(w io.Writer, cols []string, widths []int) {
 	var header []string
 	var sep []string
 	for i, col := range cols {
 		header = append(header, padToWidth(col, widths[i]))
 		sep = append(sep, strings.Repeat("─", widths[i]))
 	}
-	if _, err := fmt.Fprintln(w, strings.Join(header, "  ")); err != nil {
-		return err
-	}
-	_, err := fmt.Fprintln(w, strings.Join(sep, "  "))
-	return err
+	fmt.Fprintln(w, strings.Join(header, "  "))
+	fmt.Fprintln(w, strings.Join(sep, "  "))
 }
 
 // writeRow writes a single data row.
-func writeRow(w io.Writer, row map[string]string, cols []string, widths []int) error {
+func writeRow(w io.Writer, row map[string]string, cols []string, widths []int) {
 	var cells []string
 	for i, col := range cols {
 		val := truncateToWidth(row[col], widths[i])
 		cells = append(cells, padToWidth(val, widths[i]))
 	}
-	_, err := fmt.Fprintln(w, strings.Join(cells, "  "))
-	return err
+	fmt.Fprintln(w, strings.Join(cells, "  "))
 }
 
 // padToWidth pads a string with spaces to reach the target display width.

internal/output/testdata/runtime_context_legacy.golden.json

@@ -1,107 +0,0 @@
-{
-  "cases": {
-    "csv": {
-      "stdout": "id,name\n1,Alice\n2,Bob\n",
-      "stderr": ""
-    },
-    "format_raw_json_preserves_html": {
-      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"data\": {\n    \"html\": \"\u003cp\u003ea\u0026b\u003c/p\u003e\"\n  }\n}\n",
-      "stderr": ""
-    },
-    "jq_invalid_expression": {
-      "stdout": "",
-      "stderr": "error: invalid jq expression: unexpected EOF\n",
-      "error": {
-        "go_type": "*errs.ValidationError",
-        "json": {
-          "type": "validation",
-          "subtype": "invalid_argument",
-          "message": "invalid jq expression: unexpected EOF"
-        },
-        "message": "invalid jq expression: unexpected EOF",
-        "exit_code": 2
-      }
-    },
-    "jq_safety_alert_without_stderr_warning": {
-      "stdout": "1\n",
-      "stderr": ""
-    },
-    "jq_scalar": {
-      "stdout": "Alice\n",
-      "stderr": ""
-    },
-    "json_object": {
-      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"data\": {\n    \"enabled\": true,\n    \"id\": \"1\"\n  }\n}\n",
-      "stderr": ""
-    },
-    "metadata": {
-      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"data\": [\n    {\n      \"id\": \"1\"\n    }\n  ],\n  \"meta\": {\n    \"count\": 1,\n    \"rollback\": \"lark-cli fixture rollback\"\n  }\n}\n",
-      "stderr": ""
-    },
-    "ndjson": {
-      "stdout": "{\"id\":\"1\"}\n{\"id\":\"2\"}\n",
-      "stderr": ""
-    },
-    "notice": {
-      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"data\": {\n    \"id\": \"1\"\n  },\n  \"_notice\": {\n    \"update\": {\n      \"latest\": \"9.9.9\"\n    }\n  }\n}\n",
-      "stderr": ""
-    },
-    "partial_failure_ok_false": {
-      "stdout": "{\n  \"ok\": false,\n  \"identity\": \"bot\",\n  \"data\": {\n    \"failed\": 1,\n    \"succeeded\": 1\n  }\n}\n",
-      "stderr": "",
-      "error": {
-        "go_type": "*output.PartialFailureError",
-        "json": {
-          "Code": 1
-        },
-        "message": "partial failure (exit 1)",
-        "exit_code": 1
-      }
-    },
-    "pretty": {
-      "stdout": "pretty:fixture\n",
-      "stderr": ""
-    },
-    "pretty_without_renderer": {
-      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"data\": {\n    \"name\": \"Alice\"\n  }\n}\n",
-      "stderr": ""
-    },
-    "raw_jq_complex": {
-      "stdout": "{\n  \"html\": \"\u003cp\u003ea\u0026b\u003c/p\u003e\"\n}\n",
-      "stderr": ""
-    },
-    "raw_json_preserves_html": {
-      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"data\": {\n    \"html\": \"\u003cp\u003ea\u0026b\u003c/p\u003e\"\n  }\n}\n",
-      "stderr": ""
-    },
-    "scanner_block": {
-      "stdout": "",
-      "stderr": "",
-      "error": {
-        "go_type": "*errs.ContentSafetyError",
-        "json": {
-          "type": "policy",
-          "subtype": "content_safety",
-          "message": "content safety violation detected (rules: fixture-rule)",
-          "rules": [
-            "fixture-rule"
-          ]
-        },
-        "message": "content safety violation detected (rules: fixture-rule)",
-        "exit_code": 6
-      }
-    },
-    "scanner_error_fails_open": {
-      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"data\": {\n    \"id\": \"1\"\n  }\n}\n",
-      "stderr": "warning: content safety scan error: scanner unavailable\n"
-    },
-    "table_with_safety_warning": {
-      "stdout": "id  name \n──  ─────\n1   Alice\n",
-      "stderr": "warning: content safety alert from emitter-oracle (rules: fixture-rule)\n"
-    },
-    "unknown_format_data_envelope_notice": {
-      "stdout": "{\n  \"_notice\": {\n    \"skills\": {\n      \"current\": \"1.0.0\"\n    }\n  },\n  \"ok\": true,\n  \"value\": \"fixture\"\n}\n",
-      "stderr": "warning: unknown format \"yaml\", falling back to json\n"
-    }
-  }
-}

internal/output/testdata/write_success_envelope_legacy.golden.json

@@ -1,41 +0,0 @@
-{
-  "cases": {
-    "dry_run": {
-      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"dry_run\": true,\n  \"data\": {\n    \"api\": []\n  }\n}\n",
-      "stderr": ""
-    },
-    "jq": {
-      "stdout": "1\n",
-      "stderr": ""
-    },
-    "jq_safety_warning": {
-      "stdout": "1\n",
-      "stderr": "warning: content safety alert from emitter-oracle (rules: fixture-rule)\n"
-    },
-    "json": {
-      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"data\": {\n    \"id\": \"1\"\n  }\n}\n",
-      "stderr": ""
-    },
-    "notice": {
-      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"data\": {\n    \"id\": \"1\"\n  },\n  \"_notice\": {\n    \"update\": {\n      \"latest\": \"9.9.9\"\n    }\n  }\n}\n",
-      "stderr": ""
-    },
-    "scanner_block": {
-      "stdout": "",
-      "stderr": "",
-      "error": {
-        "go_type": "*errs.ContentSafetyError",
-        "json": {
-          "type": "policy",
-          "subtype": "content_safety",
-          "message": "content safety violation detected (rules: fixture-rule)",
-          "rules": [
-            "fixture-rule"
-          ]
-        },
-        "message": "content safety violation detected (rules: fixture-rule)",
-        "exit_code": 6
-      }
-    }
-  }
-}

internal/qualitygate/diff/diff_test.go

@@ -6,11 +6,10 @@ package diff
 import (
 	"context"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"reflect"
 	"testing"
-
-	"github.com/larksuite/cli/internal/testutil/gitcmd"
 )
 
 func TestScopeIncludesChangedSkillAndRelatedDomain(t *testing.T) {
@@ -123,7 +122,8 @@ func writeFile(t *testing.T, repo, rel, content string) {
 
 func runGit(t *testing.T, repo string, args ...string) {
 	t.Helper()
-	cmd := gitcmd.Command(repo, args...)
+	cmd := exec.Command("git", args...)
+	cmd.Dir = repo
 	if out, err := cmd.CombinedOutput(); err != nil {
 		t.Fatalf("git %v failed: %v\n%s", args, err, out)
 	}
@@ -131,7 +131,8 @@ func runGit(t *testing.T, repo string, args ...string) {
 
 func gitOutput(t *testing.T, repo string, args ...string) string {
 	t.Helper()
-	cmd := gitcmd.Command(repo, args...)
+	cmd := exec.Command("git", args...)
+	cmd.Dir = repo
 	out, err := cmd.Output()
 	if err != nil {
 		t.Fatalf("git %v failed: %v", args, err)

internal/qualitygate/publiccontent/collect_test.go

@@ -6,11 +6,10 @@ package publiccontent
 import (
 	"context"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 	"testing"
-
-	"github.com/larksuite/cli/internal/testutil/gitcmd"
 )
 
 func TestCollectScansOnlyCurrentContributionAndMetadata(t *testing.T) {
@@ -840,7 +839,8 @@ func runGit(t *testing.T, repo string, args ...string) {
 	if len(args) > 0 && args[0] == "commit" {
 		args = append([]string{"commit", "--no-verify"}, args[1:]...)
 	}
-	cmd := gitcmd.Command(repo, args...)
+	cmd := exec.Command("git", args...)
+	cmd.Dir = repo
 	out, err := cmd.CombinedOutput()
 	if err != nil {
 		t.Fatalf("git %v failed: %v\n%s", args, err, out)
@@ -849,7 +849,8 @@ func runGit(t *testing.T, repo string, args ...string) {
 
 func runGitOutput(t *testing.T, repo string, args ...string) []byte {
 	t.Helper()
-	cmd := gitcmd.Command(repo, args...)
+	cmd := exec.Command("git", args...)
+	cmd.Dir = repo
 	out, err := cmd.CombinedOutput()
 	if err != nil {
 		t.Fatalf("git %v failed: %v\n%s", args, err, out)

internal/qualitygate/rules/dryrun.go

@@ -16,7 +16,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/larksuite/cli/internal/output"
 	"github.com/larksuite/cli/internal/qualitygate/facts"
 	"github.com/larksuite/cli/internal/qualitygate/manifest"
 	"github.com/larksuite/cli/internal/qualitygate/report"
@@ -727,11 +726,7 @@ func appendDryRunArg(raw string) ([]string, error) {
 		return nil, fmt.Errorf("not a lark-cli command")
 	}
 	argv = truncateShellTail(argv)
-	var jqValid bool
-	argv, jqValid = stripDryRunJQFilter(argv)
-	if jqValid {
-		argv = forceDryRunJSONFormat(argv)
-	}
+	argv = forceDryRunJSONFormat(argv)
 	hasDryRunArg := false
 	dryRunEnabled := false
 	for _, arg := range argv[1:] {
@@ -780,73 +775,6 @@ func truncateShellTail(argv []string) []string {
 	return argv
 }
 
-// stripDryRunJQFilter removes valid output-only jq filters from the synthetic
-// dry-run invocation. Invalid jq syntax and incompatible output flags are left
-// untouched so the real CLI execution still rejects the documented command.
-// The bool reports whether other output normalization remains safe.
-func stripDryRunJQFilter(argv []string) ([]string, bool) {
-	jqExpr, outputPath, format, hasJQ, jqHasValue := dryRunOutputFlags(argv)
-	if !hasJQ {
-		return argv, true
-	}
-	if !jqHasValue || output.ValidateJqFlags(jqExpr, outputPath, format) != nil {
-		return argv, false
-	}
-
-	out := make([]string, 0, len(argv))
-	for i := 0; i < len(argv); i++ {
-		arg := argv[i]
-		switch {
-		case arg == "--":
-			return append(out, argv[i:]...), true
-		case arg == "--jq" || arg == "-q":
-			i++
-		case strings.HasPrefix(arg, "--jq=") || strings.HasPrefix(arg, "-q="):
-			continue
-		default:
-			out = append(out, arg)
-		}
-	}
-	return out, true
-}
-
-func dryRunOutputFlags(argv []string) (jqExpr, outputPath, format string, hasJQ, jqHasValue bool) {
-	for i := 1; i < len(argv); i++ {
-		arg := argv[i]
-		if arg == "--" {
-			break
-		}
-		switch {
-		case arg == "--jq" || arg == "-q":
-			hasJQ = true
-			jqHasValue = i+1 < len(argv)
-			if jqHasValue {
-				jqExpr = argv[i+1]
-				i++
-			}
-		case strings.HasPrefix(arg, "--jq=") || strings.HasPrefix(arg, "-q="):
-			hasJQ = true
-			jqHasValue = true
-			jqExpr = arg[strings.IndexByte(arg, '=')+1:]
-		case arg == "--output":
-			if i+1 < len(argv) {
-				outputPath = argv[i+1]
-				i++
-			}
-		case strings.HasPrefix(arg, "--output="):
-			outputPath = strings.TrimPrefix(arg, "--output=")
-		case arg == "--format":
-			if i+1 < len(argv) {
-				format = argv[i+1]
-				i++
-			}
-		case strings.HasPrefix(arg, "--format="):
-			format = strings.TrimPrefix(arg, "--format=")
-		}
-	}
-	return jqExpr, outputPath, format, hasJQ, jqHasValue
-}
-
 func dryRunFlagExplicitlyTrue(arg string) bool {
 	value, ok := strings.CutPrefix(arg, "--dry-run=")
 	if !ok {

internal/qualitygate/rules/dryrun_test.go

@@ -194,38 +194,6 @@ func TestRunDryRunsIgnoresTrailingShellComment(t *testing.T) {
 	}
 }
 
-func TestRunDryRunsIgnoresJQFilterWhenValidatingRequestPreview(t *testing.T) {
-	cliBin, argsPath := fakeDryRunCLI(t, `{"api":[{"method":"GET","url":"/open-apis/im/v1/flags"}]}`)
-	m := manifest.Manifest{Commands: []manifest.Command{{
-		Path:       "im +flag-list",
-		Runnable:   true,
-		Identities: []string{"user"},
-		Flags: []manifest.Flag{
-			{Name: "as", TakesValue: true},
-			{Name: "page-all"},
-			{Name: "jq", Shorthand: "q", TakesValue: true},
-			{Name: "dry-run"},
-		},
-	}}}
-	ex := skillscan.Example{
-		Raw:        `lark-cli im +flag-list --as user --page-all -q '.data.flag_items[-1]'`,
-		SourceFile: "skills/lark-im/references/lark-im-flag-list.md",
-		Line:       26,
-	}
-
-	diags, facts := RunDryRuns(context.Background(), cliBin, m, []skillscan.Example{ex})
-	if len(diags) != 0 {
-		t.Fatalf("RunDryRuns() diagnostics = %#v", diags)
-	}
-	if len(facts) != 1 || !facts[0].Executable || facts[0].SkipReason != "" {
-		t.Fatalf("jq example should remain executable: %#v", facts)
-	}
-	wantArgs := []string{"im", "+flag-list", "--as", "user", "--page-all", "--dry-run"}
-	if gotArgs := readArgs(t, argsPath); !reflect.DeepEqual(gotArgs, wantArgs) {
-		t.Fatalf("fake CLI args = %#v, want %#v", gotArgs, wantArgs)
-	}
-}
-
 func TestRunDryRunsMaterializesPlaceholdersInsideJSONFlags(t *testing.T) {
 	cliBin, argsPath := fakeDryRunCLI(t, `{"api":[{"method":"GET","url":"/open-apis/im/v1/messages","params":{"chat_id":"oc_test123","page_token":"page_test123"}}]}`)
 	m := manifest.Manifest{Commands: []manifest.Command{{
@@ -827,72 +795,6 @@ func TestAppendDryRunArgForcesInlineJSONFormat(t *testing.T) {
 	}
 }
 
-func TestAppendDryRunArgRemovesJQFilter(t *testing.T) {
-	tests := []struct {
-		name string
-		raw  string
-		want []string
-	}{
-		{
-			name: "short split",
-			raw:  `lark-cli im +flag-list --page-all -q '.data.flag_items[-1]'`,
-			want: []string{"im", "+flag-list", "--page-all", "--dry-run"},
-		},
-		{
-			name: "long split",
-			raw:  `lark-cli im +flag-list --jq '.data.flag_items[].item_id' --page-all`,
-			want: []string{"im", "+flag-list", "--page-all", "--dry-run"},
-		},
-		{
-			name: "short inline",
-			raw:  `lark-cli im +flag-list -q='.data.flag_items[-1]' --page-all`,
-			want: []string{"im", "+flag-list", "--page-all", "--dry-run"},
-		},
-		{
-			name: "long inline",
-			raw:  `lark-cli im +flag-list --jq='.data.flag_items[-1]' --page-all`,
-			want: []string{"im", "+flag-list", "--page-all", "--dry-run"},
-		},
-		{
-			name: "missing value remains invalid",
-			raw:  `lark-cli im +flag-list --page-all --jq`,
-			want: []string{"im", "+flag-list", "--page-all", "--jq", "--dry-run"},
-		},
-		{
-			name: "next flag is not accepted as jq expression",
-			raw:  `lark-cli im +flag-list --jq --page-all`,
-			want: []string{"im", "+flag-list", "--jq", "--page-all", "--dry-run"},
-		},
-		{
-			name: "invalid expression remains invalid",
-			raw:  `lark-cli im +flag-list --jq 'invalid[' --page-all`,
-			want: []string{"im", "+flag-list", "--jq", "invalid[", "--page-all", "--dry-run"},
-		},
-		{
-			name: "incompatible pretty format remains invalid",
-			raw:  `lark-cli im +flag-list --jq '.data' --format pretty`,
-			want: []string{"im", "+flag-list", "--jq", ".data", "--format", "pretty", "--dry-run"},
-		},
-		{
-			name: "compatible json format preserves request preview",
-			raw:  `lark-cli im +flag-list --jq '.data' --format json`,
-			want: []string{"im", "+flag-list", "--format", "json", "--dry-run"},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := appendDryRunArg(tt.raw)
-			if err != nil {
-				t.Fatalf("appendDryRunArg() error = %v", err)
-			}
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Fatalf("appendDryRunArg() = %#v, want %#v", got, tt.want)
-			}
-		})
-	}
-}
-
 func TestAppendDryRunArgPreservesNonPrettyFormat(t *testing.T) {
 	for _, raw := range []string{
 		"lark-cli mail +watch --format data --dry-run",

internal/qualitygate/rules/run_test.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"encoding/json"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 	"testing"
@@ -14,7 +15,6 @@ import (
 	qdiff "github.com/larksuite/cli/internal/qualitygate/diff"
 	"github.com/larksuite/cli/internal/qualitygate/manifest"
 	"github.com/larksuite/cli/internal/qualitygate/report"
-	"github.com/larksuite/cli/internal/testutil/gitcmd"
 	"github.com/larksuite/cli/internal/vfs"
 )
 
@@ -600,8 +600,7 @@ func TestNormalizeDiagnosticFileHandlesAbsoluteRepo(t *testing.T) {
 
 func runGit(t *testing.T, repo string, args ...string) {
 	t.Helper()
-	commandArgs := append([]string{"-c", "core.hooksPath=/dev/null"}, args...)
-	cmd := gitcmd.Command(repo, commandArgs...)
+	cmd := exec.Command("git", append([]string{"-c", "core.hooksPath=/dev/null", "-C", repo}, args...)...)
 	cmd.Env = append(os.Environ(), "GIT_AUTHOR_DATE=2026-06-17T00:00:00Z", "GIT_COMMITTER_DATE=2026-06-17T00:00:00Z")
 	out, err := cmd.CombinedOutput()
 	if err != nil {

internal/registry/registry_test.go

@@ -101,7 +101,6 @@ func TestSelectRecommendedScope_Empty(t *testing.T) {
 }
 
 func TestComputeMinimumScopeSet(t *testing.T) {
-	ensureFreshRegistry(t)
 	minSet := ComputeMinimumScopeSet("user")
 	if len(minSet) == 0 {
 		if len(ListFromMetaProjects()) == 0 {

internal/registry/registrytest/fixture_meta.json

@@ -1,72 +0,0 @@
-{
-  "version": "0.0.1",
-  "services": [
-    {
-      "name": "calendar",
-      "version": "v4",
-      "title": "Calendar API",
-      "servicePath": "/open-apis/calendar/v4",
-      "resources": {
-        "events": {
-          "methods": {
-            "create": {
-              "path": "calendars/{calendar_id}/events",
-              "httpMethod": "POST",
-              "risk": "write",
-              "scopes": [
-                "calendar:calendar.event:create"
-              ],
-              "parameters": {
-                "calendar_id": {
-                  "type": "string",
-                  "location": "path",
-                  "required": true
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    {
-      "name": "im",
-      "version": "v1",
-      "title": "IM API",
-      "servicePath": "/open-apis/im/v1",
-      "resources": {
-        "chat.members": {
-          "methods": {
-            "create": {
-              "path": "chats/{chat_id}/members",
-              "httpMethod": "POST",
-              "risk": "write",
-              "scopes": [
-                "im:chat",
-                "im:chat.members:write_only"
-              ],
-              "parameters": {
-                "chat_id": {
-                  "type": "string",
-                  "location": "path",
-                  "required": true
-                },
-                "member_id_type": {
-                  "type": "string",
-                  "location": "query",
-                  "required": false
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    {
-      "name": "task",
-      "version": "v2",
-      "title": "Task API",
-      "servicePath": "/open-apis/task/v2",
-      "resources": {}
-    }
-  ]
-}

internal/registry/registrytest/registrytest.go

@@ -1,146 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-// Package registrytest seeds the registry with a tracked metadata fixture so
-// command-tree tests pass on a clean checkout — no `make fetch_meta`, no
-// network, no user cache. TestMain funcs of packages that build service
-// commands call Seed after redirecting LARKSUITE_CLI_CONFIG_DIR.
-package registrytest
-
-import (
-	_ "embed"
-	"encoding/json"
-	"errors"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/registry"
-	"github.com/larksuite/cli/internal/vfs"
-)
-
-// fixtureMetaJSON is a trimmed snapshot of the generated meta_data.json
-// holding only the calendar, im and task services that registry-backed tests
-// assert against. Its version is pinned to "0.0.1": newer than the empty
-// embedded stub ("0.0.0") so it wins on a clean checkout, older than any real
-// generated catalog ("1.0.0"+) so a `make fetch_meta` build keeps testing the
-// full embedded data.
-//
-//go:embed fixture_meta.json
-var fixtureMetaJSON []byte
-
-// Seed writes fixtureMetaJSON into the registry remote-meta cache under
-// LARKSUITE_CLI_CONFIG_DIR and eagerly initializes the registry. testRoot must
-// be the temporary root created by the caller's TestMain; Seed rejects a config
-// directory outside it before performing any write. The cache
-// meta is stamped fresh so Init never sync-fetches or background-refreshes
-// over the network. Eager Init pins the catalog for the whole test process before
-// any individual test can re-point LARKSUITE_CLI_CONFIG_DIR elsewhere.
-//
-// The caller's TestMain must set LARKSUITE_CLI_CONFIG_DIR beneath testRoot
-// first; Seed refuses unset, mismatched, or escaping paths so it can never
-// write into a developer's real ~/.lark-cli.
-func Seed(testRoot string) error {
-	configDir := os.Getenv("LARKSUITE_CLI_CONFIG_DIR")
-	if err := validateConfigDir(testRoot, configDir); err != nil {
-		return err
-	}
-
-	var fixture struct {
-		Version string `json:"version"`
-	}
-	if err := json.Unmarshal(fixtureMetaJSON, &fixture); err != nil {
-		return err
-	}
-
-	cacheDir := filepath.Join(configDir, "cache")
-	if err := vfs.MkdirAll(cacheDir, 0o700); err != nil {
-		return err
-	}
-	if err := vfs.WriteFile(filepath.Join(cacheDir, "remote_meta.json"), fixtureMetaJSON, 0o644); err != nil {
-		return err
-	}
-	cacheMeta, err := json.Marshal(registry.CacheMeta{
-		LastCheckAt: time.Now().Unix(),
-		Version:     fixture.Version,
-		Brand:       string(core.BrandFeishu),
-	})
-	if err != nil {
-		return err
-	}
-	if err := vfs.WriteFile(filepath.Join(cacheDir, "remote_meta.meta.json"), cacheMeta, 0o644); err != nil {
-		return err
-	}
-
-	// Neutralize ambient knobs that would defeat the seeding: an inherited
-	// LARKSUITE_CLI_REMOTE_META=off would stop Init from reading the seeded
-	// cache at all, and LARKSUITE_CLI_META_TTL=0 would expire the freshness
-	// stamp and start a background network refresh from inside unit tests.
-	if err := os.Unsetenv("LARKSUITE_CLI_REMOTE_META"); err != nil {
-		return err
-	}
-	if err := os.Unsetenv("LARKSUITE_CLI_META_TTL"); err != nil {
-		return err
-	}
-
-	registry.Init()
-
-	// Init is a sync.Once, so the seed is pinned for the whole test process.
-	// Turning remote metadata off afterwards cannot un-seed anything; it is a
-	// guard for any future post-Init code path that might consult the remote
-	// cache again after a test re-points LARKSUITE_CLI_CONFIG_DIR elsewhere.
-	if err := os.Setenv("LARKSUITE_CLI_REMOTE_META", "off"); err != nil {
-		return err
-	}
-
-	// Self-check: both the fixture and any real generated catalog contain the
-	// im service. If it is missing, the cache seeding silently stopped working
-	// (e.g. the registry cache file names or freshness semantics changed) and
-	// every registry-backed test would fail confusingly — fail loudly here
-	// instead, pointing at this package.
-	merged, ok := registry.ServiceTyped("im")
-	if !ok {
-		return errors.New("registrytest.Seed: registry has no im service after seeding — " +
-			"the remote-cache format in internal/registry/remote.go may have changed; update registrytest to match")
-	}
-
-	// Self-check: on a fetch_meta build the real embedded catalog must win over
-	// the 0.0.1 fixture. If the merged im service diverges from the embedded
-	// one, the version arbitration flipped (e.g. the generated catalog version
-	// stopped parsing as semver) and unit tests would silently run against the
-	// stale trimmed fixture instead of the fresh catalog.
-	for _, service := range registry.EmbeddedServicesTyped() {
-		if service.Name != "im" {
-			continue
-		}
-		if service.Version != merged.Version {
-			return errors.New("registrytest.Seed: the fixture shadowed the real embedded catalog — " +
-				"check the meta_data.json version against the fixture's \"0.0.1\" arbitration in this package")
-		}
-		break
-	}
-	return nil
-}
-
-// validateConfigDir guards the one real hazard: a TestMain wiring mistake
-// pointing LARKSUITE_CLI_CONFIG_DIR at a developer's real directory. Both
-// paths come from the caller's own MkdirTemp, so a plain containment check
-// is enough.
-func validateConfigDir(testRoot, configDir string) error {
-	if testRoot == "" || configDir == "" {
-		return errors.New("registrytest.Seed: test root and config dir must be set")
-	}
-	if !filepath.IsAbs(testRoot) || !filepath.IsAbs(configDir) {
-		return errors.New("registrytest.Seed: test root and config dir must be absolute")
-	}
-	rel, err := filepath.Rel(filepath.Clean(testRoot), filepath.Clean(configDir))
-	if err != nil {
-		return err
-	}
-	if rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
-		return errors.New("registrytest.Seed: config dir must stay inside the test root")
-	}
-	return nil
-}

internal/registry/registrytest/registrytest_test.go

@@ -1,229 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package registrytest
-
-import (
-	"net/http"
-	"os"
-	"path/filepath"
-	"slices"
-	"sort"
-	"testing"
-
-	"github.com/larksuite/cli/internal/meta"
-	"github.com/larksuite/cli/internal/registry"
-)
-
-func TestValidateConfigDir(t *testing.T) {
-	root := t.TempDir()
-	tests := []struct {
-		name      string
-		testRoot  string
-		configDir string
-		wantErr   bool
-	}{
-		{name: "equal", testRoot: root, configDir: root},
-		{name: "child", testRoot: root, configDir: filepath.Join(root, "config")},
-		{
-			name:      "sibling",
-			testRoot:  root,
-			configDir: filepath.Join(filepath.Dir(root), "outside"),
-			wantErr:   true,
-		},
-		{name: "empty root", configDir: root, wantErr: true},
-		{name: "empty config", testRoot: root, wantErr: true},
-		{name: "relative root", testRoot: "relative", configDir: root, wantErr: true},
-		{name: "relative config", testRoot: root, configDir: "relative", wantErr: true},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := validateConfigDir(tt.testRoot, tt.configDir)
-			if (err != nil) != tt.wantErr {
-				t.Fatalf("validateConfigDir() error = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
-	}
-}
-
-func TestFixtureContract(t *testing.T) {
-	if len(fixtureMetaJSON) > 20<<10 {
-		t.Fatalf("fixture size = %d, want <= %d", len(fixtureMetaJSON), 20<<10)
-	}
-	reg, err := meta.Parse(fixtureMetaJSON)
-	if err != nil {
-		t.Fatalf("meta.Parse() error = %v", err)
-	}
-	if reg.Version != "0.0.1" {
-		t.Fatalf("fixture version = %q, want 0.0.1", reg.Version)
-	}
-
-	gotNames := make([]string, 0, len(reg.Services))
-	for _, service := range reg.Services {
-		gotNames = append(gotNames, service.Name)
-	}
-	sort.Strings(gotNames)
-	if !slices.Equal(gotNames, []string{"calendar", "im", "task"}) {
-		t.Fatalf("fixture services = %v, want [calendar im task]", gotNames)
-	}
-
-	calendarCreate := fixtureMethod(t, reg, "calendar", "events", "create")
-	assertMethodContract(t, calendarCreate, "calendars/{calendar_id}/events", http.MethodPost)
-	calendarID, ok := calendarCreate.Parameters["calendar_id"]
-	if !ok || calendarID.Location != "path" || !calendarID.Required {
-		t.Fatalf("calendar_id = %+v, want required path parameter", calendarID)
-	}
-	if !slices.Contains(calendarCreate.Scopes, "calendar:calendar.event:create") {
-		t.Fatalf("calendar create scopes = %v, want calendar:calendar.event:create", calendarCreate.Scopes)
-	}
-
-	imCreate := fixtureMethod(t, reg, "im", "chat.members", "create")
-	assertMethodContract(t, imCreate, "chats/{chat_id}/members", http.MethodPost)
-	chatID, ok := imCreate.Parameters["chat_id"]
-	if !ok || chatID.Location != "path" || !chatID.Required {
-		t.Fatalf("chat_id = %+v, want required path parameter", chatID)
-	}
-	memberIDType, ok := imCreate.Parameters["member_id_type"]
-	if !ok || memberIDType.Location != "query" || memberIDType.Required {
-		t.Fatalf("member_id_type = %+v, want optional query parameter", memberIDType)
-	}
-	if imCreate.Risk != "write" {
-		t.Fatalf("im create risk = %q, want write", imCreate.Risk)
-	}
-	for _, scope := range []string{"im:chat", "im:chat.members:write_only"} {
-		if !slices.Contains(imCreate.Scopes, scope) {
-			t.Fatalf("im create scopes = %v, want %s", imCreate.Scopes, scope)
-		}
-	}
-}
-
-func fixtureMethod(t *testing.T, reg meta.Registry, serviceName, resourceName, methodName string) meta.Method {
-	t.Helper()
-	for _, service := range reg.Services {
-		if service.Name != serviceName {
-			continue
-		}
-		resource, ok := service.Resource(resourceName)
-		if !ok {
-			t.Fatalf("fixture service %s has no resource %s", serviceName, resourceName)
-		}
-		method, ok := resource.Method(methodName)
-		if !ok {
-			t.Fatalf("fixture resource %s.%s has no method %s", serviceName, resourceName, methodName)
-		}
-		return method
-	}
-	t.Fatalf("fixture has no service %s", serviceName)
-	return meta.Method{}
-}
-
-func assertMethodContract(t *testing.T, method meta.Method, path, httpMethod string) {
-	t.Helper()
-	if method.Path != path || method.HTTPMethod != httpMethod {
-		t.Fatalf("method = %s %s, want %s %s", method.HTTPMethod, method.Path, httpMethod, path)
-	}
-}
-
-// TestSeedRejectsUnsafeConfigDir pins Seed's guard: it must return before
-// writing anything when LARKSUITE_CLI_CONFIG_DIR is unset or escapes the
-// caller's test root, so a TestMain wiring mistake can never touch a
-// developer's real ~/.lark-cli.
-func TestSeedRejectsUnsafeConfigDir(t *testing.T) {
-	root := t.TempDir()
-
-	t.Run("unset config dir", func(t *testing.T) {
-		t.Setenv("LARKSUITE_CLI_CONFIG_DIR", "")
-		if err := Seed(root); err == nil {
-			t.Fatal("Seed() error = nil, want unset config dir rejection")
-		}
-	})
-
-	t.Run("config dir outside test root", func(t *testing.T) {
-		outside := t.TempDir()
-		t.Setenv("LARKSUITE_CLI_CONFIG_DIR", outside)
-		if err := Seed(root); err == nil {
-			t.Fatal("Seed() error = nil, want containment rejection")
-		}
-		if _, err := os.Stat(filepath.Join(outside, "cache")); err == nil {
-			t.Fatal("Seed wrote into the rejected config dir")
-		}
-	})
-}
-
-// TestSeedWritesFixtureAndInitializesRegistry covers the seeding happy path:
-// cache files land under the config dir, the registry initializes from them,
-// and both self-checks pass.
-func TestSeedWritesFixtureAndInitializesRegistry(t *testing.T) {
-	root := t.TempDir()
-	configDir := filepath.Join(root, "config")
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", configDir)
-
-	if err := Seed(root); err != nil {
-		t.Fatalf("Seed() error = %v, want nil", err)
-	}
-	for _, name := range []string{"remote_meta.json", "remote_meta.meta.json"} {
-		if _, err := os.Stat(filepath.Join(configDir, "cache", name)); err != nil {
-			t.Errorf("cache file %s: %v", name, err)
-		}
-	}
-	if got := os.Getenv("LARKSUITE_CLI_REMOTE_META"); got != "off" {
-		t.Errorf("LARKSUITE_CLI_REMOTE_META = %q, want off after seeding", got)
-	}
-	for _, service := range []string{"calendar", "im", "task"} {
-		if _, ok := registry.ServiceTyped(service); !ok {
-			t.Errorf("registry missing service %s after seeding", service)
-		}
-	}
-}
-
-// TestSeedPropagatesCacheSetupFailures pins that filesystem failures while
-// materializing the cache surface as errors instead of leaving the registry
-// silently unseeded. Each obstacle is a same-named file/directory in the
-// way, which fails on every platform without permission tricks.
-func TestSeedPropagatesCacheSetupFailures(t *testing.T) {
-	seedWith := func(t *testing.T, prepare func(root, configDir string)) error {
-		t.Helper()
-		root := t.TempDir()
-		configDir := filepath.Join(root, "config")
-		prepare(root, configDir)
-		t.Setenv("LARKSUITE_CLI_CONFIG_DIR", configDir)
-		return Seed(root)
-	}
-
-	t.Run("cache dir creation fails", func(t *testing.T) {
-		err := seedWith(t, func(root, configDir string) {
-			// config is a regular file, so MkdirAll(config/cache) fails.
-			if err := os.WriteFile(configDir, nil, 0o600); err != nil {
-				t.Fatal(err)
-			}
-		})
-		if err == nil {
-			t.Fatal("Seed() error = nil, want cache dir creation failure")
-		}
-	})
-
-	t.Run("fixture write fails", func(t *testing.T) {
-		err := seedWith(t, func(root, configDir string) {
-			// remote_meta.json is a directory, so WriteFile fails.
-			if err := os.MkdirAll(filepath.Join(configDir, "cache", "remote_meta.json"), 0o700); err != nil {
-				t.Fatal(err)
-			}
-		})
-		if err == nil {
-			t.Fatal("Seed() error = nil, want fixture write failure")
-		}
-	})
-
-	t.Run("cache meta write fails", func(t *testing.T) {
-		err := seedWith(t, func(root, configDir string) {
-			// remote_meta.meta.json is a directory, so WriteFile fails.
-			if err := os.MkdirAll(filepath.Join(configDir, "cache", "remote_meta.meta.json"), 0o700); err != nil {
-				t.Fatal(err)
-			}
-		})
-		if err == nil {
-			t.Fatal("Seed() error = nil, want cache meta write failure")
-		}
-	})
-}

internal/registry/testmain_test.go

@@ -1,27 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package registry
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestMain(m *testing.M) {
-	root, err := os.MkdirTemp("", "lark-cli-registry-test-*")
-	if err != nil {
-		panic(err)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", filepath.Join(root, "config")); err != nil {
-		panic(err)
-	}
-	code := m.Run()
-	// A test that ran Init without a trailing resetInit can leave a background
-	// refresh goroutine alive; removing the temp root while it writes would
-	// let it recreate the directory after cleanup. Wait it out first.
-	waitBackgroundRefresh()
-	_ = os.RemoveAll(root)
-	os.Exit(code)
-}

internal/riskcontrol/osmodel.go

@@ -1,142 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-// Package deviceinfo collects the platform hardware product model and the
-// platform values used by device-related risk-control headers.
-package riskcontrol
-
-import (
-	"runtime"
-	"strings"
-	"sync"
-	"unicode"
-	"unicode/utf8"
-
-	"golang.org/x/net/http/httpguts"
-)
-
-// OSType is the server-side risk-control operating-system enum.
-type OSType string
-
-// OS type enum values for X-Agent-Os-Type.
-const (
-	OSTypeUnknown = "0"
-	OSTypeWindows = "1"
-	OSTypeLinux   = "2"
-	OSTypeMacOS   = "3"
-)
-
-const (
-	// TerminalTypePC is the fixed X-Agent-Terminal-Type value for the CLI.
-	TerminalTypePC = "1"
-
-	// Unknown is used when the hardware product model cannot be collected.
-	Unknown = "Unknown"
-
-	// deviceModelMaxBytes bounds the value added to X-Agent-Device-Type.
-	// Device models are short identifiers; a larger value is treated as
-	// malformed rather than truncated so the header never misrepresents it.
-	deviceModelMaxBytes = 256
-)
-
-// Snapshot contains the deliberately small risk-control signal set.
-// ProductModel is omitted when the platform cannot provide a safe value.
-type Snapshot struct {
-	OSType       OSType
-	ProductModel string
-}
-
-// Source supplies one immutable process-level snapshot.
-type Source interface {
-	Snapshot() Snapshot
-}
-
-// HostSource lazily reads host signals once, after outbound policy authorizes
-// the first request. Failed probes are cached and are not retried per request.
-type HostSource struct {
-	once      sync.Once
-	value     Snapshot
-	readModel func() string
-}
-
-// NewHostSource creates the production host signal source.
-func NewHostSource() *HostSource {
-	return &HostSource{readModel: readDeviceModel}
-}
-
-// Snapshot returns the cached host signal snapshot.
-func (s *HostSource) Snapshot() Snapshot {
-	if s == nil {
-		return Snapshot{}
-	}
-	s.once.Do(func() {
-		readModel := s.readModel
-		if readModel == nil {
-			readModel = readDeviceModel
-		}
-		s.value = Snapshot{
-			OSType:       GetOSType(OSName()),
-			ProductModel: normalizeDeviceModel(readModel()),
-		}
-	})
-	return s.value
-}
-
-// normalizeModel removes non-printable characters and returns a model only
-// when the remaining text is safe to use as an HTTP header value. Input that
-// cannot produce a valid model is rejected so Get can fall back to Unknown.
-func normalizeDeviceModel(model string) string {
-	if !utf8.ValidString(model) {
-		return ""
-	}
-	model = strings.Map(func(r rune) rune {
-		switch {
-		case r == '\r' || r == '\n' || r == '\x00':
-			return -1
-		case unicode.IsSpace(r):
-			return ' '
-		case unicode.IsPrint(r):
-			return r
-		default:
-			return -1
-		}
-	}, model)
-
-	model = strings.Join(strings.Fields(model), " ")
-
-	if model == "" || len(model) > deviceModelMaxBytes {
-		return ""
-	}
-	if !httpguts.ValidHeaderFieldValue(model) {
-		return ""
-	}
-	return model
-}
-
-// GetOSType maps a platform name to the X-Agent-Os-Type enum.
-func GetOSType(osName string) OSType {
-	switch osName {
-	case "Windows":
-		return OSTypeWindows
-	case "Linux":
-		return OSTypeLinux
-	case "MacOS":
-		return OSTypeMacOS
-	default:
-		return OSTypeUnknown
-	}
-}
-
-// OSName returns the platform name used by GetOSType.
-func OSName() string {
-	switch runtime.GOOS {
-	case "darwin":
-		return "MacOS"
-	case "windows":
-		return "Windows"
-	case "linux":
-		return "Linux"
-	default:
-		return runtime.GOOS
-	}
-}

internal/riskcontrol/osmodel_darwin.go

@@ -1,27 +0,0 @@
-//go:build darwin
-
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package riskcontrol
-
-import "golang.org/x/sys/unix"
-
-// readDeviceModel reads the current product key first and falls back to the
-// legacy model key. Trying both keys is more robust than branching on a macOS
-// version because virtualized or restricted environments may expose only one.
-func readDeviceModel() string {
-	return readDarwinDeviceModel(unix.Sysctl)
-}
-
-func readDarwinDeviceModel(readSysctl func(string) (string, error)) string {
-	for _, key := range [...]string{"hw.product", "hw.model"} {
-		model, err := readSysctl(key)
-		if err == nil {
-			if model = normalizeDeviceModel(model); model != "" {
-				return model
-			}
-		}
-	}
-	return ""
-}

internal/riskcontrol/osmodel_darwin_test.go

@@ -1,48 +0,0 @@
-//go:build darwin
-
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package riskcontrol
-
-import (
-	"errors"
-	"reflect"
-	"testing"
-)
-
-func TestReadDarwinDeviceModelPrefersProductAndFallsBackToModel(t *testing.T) {
-	t.Run("product available", func(t *testing.T) {
-		var keys []string
-		got := readDarwinDeviceModel(func(key string) (string, error) {
-			keys = append(keys, key)
-			if key == "hw.product" {
-				return "Mac16,1", nil
-			}
-			return "", errors.New("unexpected fallback")
-		})
-		if got != "Mac16,1" {
-			t.Fatalf("model = %q, want %q", got, "Mac16,1")
-		}
-		if want := []string{"hw.product"}; !reflect.DeepEqual(keys, want) {
-			t.Fatalf("sysctl keys = %v, want %v", keys, want)
-		}
-	})
-
-	t.Run("product unavailable", func(t *testing.T) {
-		var keys []string
-		got := readDarwinDeviceModel(func(key string) (string, error) {
-			keys = append(keys, key)
-			if key == "hw.model" {
-				return "MacBookPro18,3", nil
-			}
-			return "", errors.New("not available")
-		})
-		if got != "MacBookPro18,3" {
-			t.Fatalf("model = %q, want %q", got, "MacBookPro18,3")
-		}
-		if want := []string{"hw.product", "hw.model"}; !reflect.DeepEqual(keys, want) {
-			t.Fatalf("sysctl keys = %v, want %v", keys, want)
-		}
-	})
-}

internal/riskcontrol/osmodel_linux.go

@@ -1,17 +0,0 @@
-//go:build linux
-
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package riskcontrol
-
-// readDeviceModel returns a stable device model for Linux. DMI and device-tree
-// values vary widely and can expose the host or virtualization platform when
-// the CLI runs in a container or sandbox.
-func readDeviceModel() string {
-	return readLinuxDeviceModel()
-}
-
-func readLinuxDeviceModel() string {
-	return "linux"
-}

internal/riskcontrol/osmodel_linux_test.go

@@ -1,20 +0,0 @@
-//go:build linux
-
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package riskcontrol
-
-import "testing"
-
-func TestReadDeviceModelReturnsLinux(t *testing.T) {
-	if got := readDeviceModel(); got != "linux" {
-		t.Fatalf("readDeviceModel() = %q, want %q", got, "linux")
-	}
-}
-
-func TestReadLinuxDeviceModel(t *testing.T) {
-	if got := readLinuxDeviceModel(); got != "linux" {
-		t.Fatalf("readLinuxDeviceModel() = %q, want %q", got, "linux")
-	}
-}

internal/riskcontrol/osmodel_other.go

@@ -1,11 +0,0 @@
-//go:build !darwin && !windows && !linux
-
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package riskcontrol
-
-// readDeviceModel returns an empty model on unsupported platforms.
-func readDeviceModel() string {
-	return ""
-}

internal/riskcontrol/osmodel_test.go

@@ -1,143 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package riskcontrol
-
-import (
-	"fmt"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"unicode"
-)
-
-func TestHostSourceCachesNonEmptyModel(t *testing.T) {
-	calls := 0
-	s := &HostSource{readModel: func() string {
-		calls++
-		return "  MacBookPro18,3\n"
-	}}
-
-	if got := s.Snapshot(); got.ProductModel != "MacBookPro18,3" {
-		t.Fatalf("first Snapshot().ProductModel = %q, want %q", got.ProductModel, "MacBookPro18,3")
-	}
-	if got := s.Snapshot(); got.ProductModel != "MacBookPro18,3" {
-		t.Fatalf("second Snapshot().ProductModel = %q, want cached model", got.ProductModel)
-	}
-	if calls != 1 {
-		t.Fatalf("read called %d times, want 1", calls)
-	}
-}
-
-func TestHostSourceCachesEmptyModel(t *testing.T) {
-	calls := 0
-	s := &HostSource{readModel: func() string {
-		calls++
-		return ""
-	}}
-
-	if got := s.Snapshot(); got.ProductModel != "" {
-		t.Fatalf("first Snapshot().ProductModel = %q, want empty", got.ProductModel)
-	}
-	if got := s.Snapshot(); got.ProductModel != "" {
-		t.Fatalf("second Snapshot().ProductModel = %q, want cached empty result", got.ProductModel)
-	}
-	if calls != 1 {
-		t.Fatalf("read called %d times, want 1", calls)
-	}
-}
-
-func TestHostSourceReadsOnceAcrossConcurrentCalls(t *testing.T) {
-	var calls atomic.Int32
-	s := &HostSource{readModel: func() string {
-		calls.Add(1)
-		return "ThinkPad X1 Carbon"
-	}}
-
-	const goroutines = 32
-	var wg sync.WaitGroup
-	wg.Add(goroutines)
-	for i := 0; i < goroutines; i++ {
-		go func() {
-			defer wg.Done()
-			snapshot := s.Snapshot()
-			if snapshot.ProductModel != "ThinkPad X1 Carbon" {
-				t.Errorf("Snapshot().ProductModel = %q, want %q", snapshot.ProductModel, "ThinkPad X1 Carbon")
-			}
-		}()
-	}
-	wg.Wait()
-
-	if got := calls.Load(); got != 1 {
-		t.Fatalf("read called %d times, want 1", got)
-	}
-}
-
-func TestNormalizeDeviceModel(t *testing.T) {
-	tests := []struct {
-		name  string
-		model string
-		want  string
-	}{
-		{name: "trims surrounding whitespace", model: "  MacBookPro18,3\n", want: "MacBookPro18,3"},
-		{name: "trims device tree terminator", model: "Raspberry Pi 5\x00", want: "Raspberry Pi 5"},
-		{name: "allows printable Unicode", model: "联想 ThinkPad X1", want: "联想 ThinkPad X1"},
-		{name: "rejects empty", model: " \t\r\n"},
-		{name: "rejects invalid UTF-8", model: string([]byte{'M', 0xff, '1'})},
-		{name: "removes CRLF", model: "model\r\nname", want: "modelname"},
-		{name: "normalizes tab", model: "model\tname", want: "model name"},
-		{name: "removes NUL", model: "model\x00name", want: "modelname"},
-		{name: "removes control character", model: "model\x1fname", want: "modelname"},
-		{name: "removes DEL", model: "model\x7fname", want: "modelname"},
-		{name: "normalizes Unicode line separator", model: "model\u2028name", want: "model name"},
-		{name: "collapses whitespace", model: "  model\t \u00a0 name  ", want: "model name"},
-		{name: "accepts maximum byte length", model: strings.Repeat("a", deviceModelMaxBytes), want: strings.Repeat("a", deviceModelMaxBytes)},
-		{name: "rejects overlong value", model: strings.Repeat("a", deviceModelMaxBytes+1)},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := normalizeDeviceModel(tt.model); got != tt.want {
-				t.Fatalf("normalizeDeviceModel(%q) = %q, want %q", tt.model, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestNormalizeDeviceModelRemovesHTTPControlBytes(t *testing.T) {
-	for value := 0; value <= 0x7f; value++ {
-		if value >= 0x20 && value < 0x7f {
-			continue
-		}
-		t.Run(fmt.Sprintf("0x%02x", value), func(t *testing.T) {
-			model := "model" + string(rune(value)) + "name"
-			want := "modelname"
-			if value != '\r' && value != '\n' && value != '\x00' && unicode.IsSpace(rune(value)) {
-				want = "model name"
-			}
-			if got := normalizeDeviceModel(model); got != want {
-				t.Fatalf("normalizeDeviceModel(%q) = %q, want %q", model, got, want)
-			}
-		})
-	}
-}
-
-func TestGetOSType(t *testing.T) {
-	tests := []struct {
-		name string
-		want OSType
-	}{
-		{name: "Windows", want: OSTypeWindows},
-		{name: "Linux", want: OSTypeLinux},
-		{name: "MacOS", want: OSTypeMacOS},
-		{name: "unknown", want: OSTypeUnknown},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := GetOSType(tt.name); got != tt.want {
-				t.Errorf("GetOSType(%q) = %q, want %q", tt.name, got, tt.want)
-			}
-		})
-	}
-}

internal/riskcontrol/osmodel_windows.go

@@ -1,44 +0,0 @@
-//go:build windows
-
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package riskcontrol
-
-import "golang.org/x/sys/windows/registry"
-
-// systemInfoRegistryPaths lists registry locations in device-model lookup order.
-var systemInfoRegistryPaths = [...]string{
-	`HARDWARE\DESCRIPTION\System\BIOS`,
-	`SYSTEM\CurrentControlSet\Control\SystemInformation`,
-	`SYSTEM\HardwareConfig\Current`,
-}
-
-// readDeviceModel returns the first product name found in the Windows registry.
-func readDeviceModel() string {
-	return readWindowsDeviceModel(readWindowsRegistryModel)
-}
-
-func readWindowsRegistryModel(path string) (string, error) {
-	key, err := registry.OpenKey(registry.LOCAL_MACHINE, path, registry.READ)
-	if err != nil {
-		return "", err
-	}
-	defer key.Close()
-
-	model, _, err := key.GetStringValue("SystemProductName")
-	return model, err
-}
-
-func readWindowsDeviceModel(readRegistryModel func(string) (string, error)) string {
-	for _, path := range systemInfoRegistryPaths {
-		model, err := readRegistryModel(path)
-		if err != nil {
-			continue
-		}
-		if model = normalizeDeviceModel(model); model != "" {
-			return model
-		}
-	}
-	return ""
-}

internal/riskcontrol/osmodel_windows_test.go

@@ -1,78 +0,0 @@
-//go:build windows
-
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package riskcontrol
-
-import (
-	"errors"
-	"reflect"
-	"testing"
-)
-
-func TestReadWindowsDeviceModelFallback(t *testing.T) {
-	readError := errors.New("registry read failed")
-	tests := []struct {
-		name      string
-		values    map[string]string
-		errors    map[string]error
-		want      string
-		wantPaths []string
-	}{
-		{
-			name:      "first path wins",
-			values:    map[string]string{systemInfoRegistryPaths[0]: "Surface Laptop"},
-			want:      "Surface Laptop",
-			wantPaths: []string{systemInfoRegistryPaths[0]},
-		},
-		{
-			name: "read failure falls back",
-			errors: map[string]error{
-				systemInfoRegistryPaths[0]: readError,
-			},
-			values: map[string]string{
-				systemInfoRegistryPaths[1]: "ThinkPad X1 Carbon",
-			},
-			want:      "ThinkPad X1 Carbon",
-			wantPaths: systemInfoRegistryPaths[:2],
-		},
-		{
-			name: "empty normalized value falls back",
-			values: map[string]string{
-				systemInfoRegistryPaths[0]: " \r\n\x00",
-				systemInfoRegistryPaths[1]: "Latitude 7450",
-			},
-			want:      "Latitude 7450",
-			wantPaths: systemInfoRegistryPaths[:2],
-		},
-		{
-			name: "all paths fail",
-			errors: map[string]error{
-				systemInfoRegistryPaths[0]: readError,
-				systemInfoRegistryPaths[1]: readError,
-				systemInfoRegistryPaths[2]: readError,
-			},
-			wantPaths: systemInfoRegistryPaths[:],
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			var paths []string
-			got := readWindowsDeviceModel(func(path string) (string, error) {
-				paths = append(paths, path)
-				if err := tt.errors[path]; err != nil {
-					return "", err
-				}
-				return tt.values[path], nil
-			})
-			if got != tt.want {
-				t.Fatalf("model = %q, want %q", got, tt.want)
-			}
-			if !reflect.DeepEqual(paths, tt.wantPaths) {
-				t.Fatalf("registry paths = %v, want %v", paths, tt.wantPaths)
-			}
-		})
-	}
-}

internal/riskcontrol/transport.go

@@ -1,138 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package riskcontrol
-
-import (
-	"net/http"
-	"net/url"
-	"strings"
-
-	"github.com/larksuite/cli/internal/core"
-	internaltransport "github.com/larksuite/cli/internal/transport"
-)
-
-const (
-	HeaderProductModel = "X-Agent-Device-Type"
-	HeaderOSType       = "X-Agent-Os-Type"
-)
-
-var restrictedHeaders = [...]string{HeaderProductModel, HeaderOSType}
-
-// Transport is the feature's final outbound boundary. It removes caller- or
-// extension-supplied signal headers first and writes trusted values only after
-// authorizing an official SDK origin and authentication state.
-type Transport struct {
-	next   http.RoundTripper
-	source Source
-}
-
-// NewTransport creates the final SDK outbound policy boundary. A nil source
-// disables collection and injection while preserving restricted-header
-// stripping for opt-out and extension-credential requests.
-func NewTransport(next http.RoundTripper, source Source) *Transport {
-	if next == nil {
-		next = internaltransport.Fallback()
-	}
-	return &Transport{
-		next:   next,
-		source: source,
-	}
-}
-
-// RoundTrip implements http.RoundTripper.
-func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) {
-	req = req.Clone(req.Context())
-	if req.Header == nil {
-		req.Header = make(http.Header)
-	}
-	stripRestrictedHeaders(req.Header)
-
-	if t.source != nil && t.routeAllowsSignals(req) {
-		snapshot := t.source.Snapshot()
-		if isSupportedOSType(snapshot.OSType) {
-			req.Header.Set(HeaderOSType, string(snapshot.OSType))
-		}
-		if model := normalizeDeviceModel(snapshot.ProductModel); model != "" {
-			req.Header.Set(HeaderProductModel, model)
-		}
-	}
-	return t.next.RoundTrip(req)
-}
-
-func isSupportedOSType(value OSType) bool {
-	switch value {
-	case OSTypeWindows, OSTypeLinux, OSTypeMacOS:
-		return true
-	default:
-		return false
-	}
-}
-
-func stripRestrictedHeaders(header http.Header) {
-	for name := range header {
-		for _, restricted := range restrictedHeaders {
-			if strings.EqualFold(name, restricted) {
-				delete(header, name)
-				break
-			}
-		}
-	}
-}
-
-type origin struct {
-	scheme string
-	host   string
-	port   string
-}
-
-var officialFeishuOrigins = [...]origin{
-	apiOrigin(core.BrandFeishu, core.ResolveEndpoints(core.BrandFeishu).Open),
-	apiOrigin(core.BrandLark, core.ResolveEndpoints(core.BrandLark).Open),
-	apiOrigin(core.BrandFeishu, core.ResolveEndpoints(core.BrandFeishu).Accounts),
-	apiOrigin(core.BrandLark, core.ResolveEndpoints(core.BrandLark).Accounts),
-}
-
-func (t *Transport) routeAllowsSignals(req *http.Request) bool {
-	if req == nil || req.URL == nil {
-		return false
-	}
-	return isOfficialFeishuOrigin(originOf(req.URL))
-}
-
-func originOf(value *url.URL) origin {
-	if value == nil {
-		return origin{}
-	}
-	scheme := strings.ToLower(value.Scheme)
-	port := value.Port()
-	if port == "" {
-		switch scheme {
-		case "https":
-			port = "443"
-		case "http":
-			port = "80"
-		}
-	}
-	return origin{scheme: scheme, host: strings.ToLower(value.Hostname()), port: port}
-}
-
-func apiOrigin(brand core.LarkBrand, endpointURL string) origin {
-	endpoint, err := url.Parse(endpointURL)
-	if err != nil {
-		return origin{}
-	}
-	return originOf(endpoint)
-}
-
-func isOfficialFeishuOrigin(candidate origin) bool {
-	if candidate.scheme != "https" || candidate.port != "443" {
-		return false
-	}
-	for _, official := range officialFeishuOrigins {
-		if candidate == official {
-			return true
-		}
-	}
-	return false
-}

internal/riskcontrol/transport_test.go

@@ -1,124 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package riskcontrol
-
-import (
-	"net/http"
-	"strings"
-	"sync/atomic"
-	"testing"
-)
-
-type roundTripFunc func(*http.Request) (*http.Response, error)
-
-func (f roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
-	return f(req)
-}
-
-type countingSource struct {
-	calls atomic.Int32
-}
-
-func (s *countingSource) Snapshot() Snapshot {
-	s.calls.Add(1)
-	return Snapshot{OSType: OSTypeMacOS, ProductModel: "Mac16,1"}
-}
-
-type staticSource Snapshot
-
-func (s staticSource) Snapshot() Snapshot { return Snapshot(s) }
-
-func TestTransportAuthorizesBeforeCollecting(t *testing.T) {
-	tests := []struct {
-		name          string
-		requestURL    string
-		authorization string
-		wantSignals   bool
-	}{
-		{name: "authenticated official HTTPS", requestURL: "https://open.feishu.cn/open-apis/test", authorization: "Bearer token", wantSignals: true},
-		{name: "Lark official HTTPS", requestURL: "https://open.larksuite.com/open-apis/test", authorization: "Bearer token", wantSignals: true},
-		{name: "official explicit HTTPS port", requestURL: "https://OPEN.FEISHU.CN:443/open-apis/test", authorization: "Bearer token", wantSignals: true},
-		{name: "unauthenticated", requestURL: "https://open.feishu.cn/open-apis/test", wantSignals: true},
-		{name: "official non-OpenAPI origin", requestURL: "https://accounts.feishu.cn/open-apis/test", authorization: "Bearer token", wantSignals: true},
-		{name: "off domain", requestURL: "https://example.com/test", authorization: "Bearer token", wantSignals: false},
-		{name: "lookalike", requestURL: "https://open.feishu.cn.evil.example/test", authorization: "Bearer token", wantSignals: false},
-		{name: "plain HTTP", requestURL: "http://open.feishu.cn/test", authorization: "Bearer token", wantSignals: false},
-		{name: "non-default port", requestURL: "https://open.feishu.cn:8443/test", authorization: "Bearer token", wantSignals: false},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			source := &countingSource{}
-			var received http.Header
-			base := roundTripFunc(func(req *http.Request) (*http.Response, error) {
-				received = req.Header.Clone()
-				return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}, nil
-			})
-			req, err := http.NewRequest(http.MethodGet, test.requestURL, nil)
-			if err != nil {
-				t.Fatal(err)
-			}
-			req.Header.Set("Authorization", test.authorization)
-			req.Header.Set(HeaderOSType, "caller-value")
-			req.Header.Set(HeaderProductModel, "caller-value")
-			req.Header["x-agent-device-type"] = []string{"non-canonical-caller-value"}
-
-			resp, err := NewTransport(base, source).RoundTrip(req)
-			if err != nil {
-				t.Fatal(err)
-			}
-			resp.Body.Close()
-
-			gotSignals := received.Get(HeaderOSType) != ""
-			if gotSignals != test.wantSignals {
-				t.Fatalf("signals present = %t, want %t; headers=%v", gotSignals, test.wantSignals, received)
-			}
-			wantCalls := int32(0)
-			if test.wantSignals {
-				wantCalls = 1
-			}
-			if got := source.calls.Load(); got != wantCalls {
-				t.Fatalf("Snapshot calls = %d, want %d", got, wantCalls)
-			}
-			if got := req.Header.Get(HeaderOSType); got != "caller-value" {
-				t.Fatalf("caller request OS header = %q, want unchanged", got)
-			}
-			if got := req.Header.Get(HeaderProductModel); got != "caller-value" {
-				t.Fatalf("caller request product-model header = %q, want unchanged", got)
-			}
-			if !test.wantSignals {
-				for name := range received {
-					if strings.EqualFold(name, HeaderProductModel) || strings.EqualFold(name, HeaderOSType) {
-						t.Fatalf("restricted header leaked as %q", name)
-					}
-				}
-			}
-		})
-	}
-}
-
-func TestTransportValidatesSourceSnapshot(t *testing.T) {
-	var received http.Header
-	base := roundTripFunc(func(req *http.Request) (*http.Response, error) {
-		received = req.Header.Clone()
-		return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}, nil
-	})
-	req, err := http.NewRequest(http.MethodGet, "https://open.feishu.cn/open-apis/test", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	req.Header.Set("Authorization", "Bearer token")
-
-	resp, err := NewTransport(base, staticSource{
-		OSType:       OSType("unsupported"),
-		ProductModel: "unsafe\nvalue",
-	}).RoundTrip(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	resp.Body.Close()
-	if received.Get(HeaderOSType) == "" && received.Get(HeaderProductModel) == "" {
-		t.Fatalf("no signals collected: %v", received)
-	}
-}

internal/testutil/gitcmd/gitcmd.go

@@ -1,55 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-// Package gitcmd provides Git process helpers for tests that use temporary
-// repositories.
-package gitcmd
-
-import (
-	"os"
-	"os/exec"
-	"strconv"
-	"testing"
-)
-
-const (
-	maintenanceAutoDetach = "maintenance.autoDetach"
-	gcAutoDetach          = "gc.autoDetach"
-)
-
-// Command creates a Git command whose automatic maintenance stays in the
-// command lifecycle, so temporary repository cleanup cannot race a detached
-// maintenance process.
-func Command(dir string, args ...string) *exec.Cmd {
-	commandArgs := make([]string, 0, len(args)+4)
-	commandArgs = append(commandArgs,
-		"-c", maintenanceAutoDetach+"=false",
-		"-c", gcAutoDetach+"=false",
-	)
-	commandArgs = append(commandArgs, args...)
-	cmd := exec.Command("git", commandArgs...)
-	cmd.Dir = dir
-	return cmd
-}
-
-// SetSynchronousMaintenanceEnv applies the same lifecycle contract to every
-// Git process started by the current test, including processes created through
-// production command runners. Tests using it must not run in parallel.
-func SetSynchronousMaintenanceEnv(t *testing.T) {
-	t.Helper()
-	count := 0
-	if value, ok := os.LookupEnv("GIT_CONFIG_COUNT"); ok {
-		parsed, err := strconv.Atoi(value)
-		if err != nil || parsed < 0 {
-			t.Fatalf("invalid GIT_CONFIG_COUNT %q", value)
-		}
-		count = parsed
-	}
-	for _, key := range []string{maintenanceAutoDetach, gcAutoDetach} {
-		index := strconv.Itoa(count)
-		t.Setenv("GIT_CONFIG_KEY_"+index, key)
-		t.Setenv("GIT_CONFIG_VALUE_"+index, "false")
-		count++
-	}
-	t.Setenv("GIT_CONFIG_COUNT", strconv.Itoa(count))
-}

internal/testutil/gitcmd/gitcmd_test.go

@@ -1,47 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package gitcmd
-
-import (
-	"os/exec"
-	"strings"
-	"testing"
-)
-
-func TestCommandDisablesDetachedMaintenance(t *testing.T) {
-	for _, key := range []string{"maintenance.autoDetach", "gc.autoDetach"} {
-		cmd := Command(t.TempDir(), "config", "--get", "--type=bool", key)
-		out, err := cmd.CombinedOutput()
-		if err != nil {
-			t.Fatalf("git config %s: %v\n%s", key, err, out)
-		}
-		if got := strings.TrimSpace(string(out)); got != "false" {
-			t.Fatalf("%s = %q, want false", key, got)
-		}
-	}
-}
-
-func TestSetSynchronousMaintenanceEnv(t *testing.T) {
-	t.Setenv("GIT_CONFIG_COUNT", "1")
-	t.Setenv("GIT_CONFIG_KEY_0", "user.name")
-	t.Setenv("GIT_CONFIG_VALUE_0", "Existing Test User")
-	SetSynchronousMaintenanceEnv(t)
-	for key, want := range map[string]string{
-		"user.name":           "Existing Test User",
-		maintenanceAutoDetach: "false",
-		gcAutoDetach:          "false",
-	} {
-		cmd := exec.Command("git", "config", "--get", "--type=bool", key)
-		if key == "user.name" {
-			cmd = exec.Command("git", "config", "--get", key)
-		}
-		out, err := cmd.CombinedOutput()
-		if err != nil {
-			t.Fatalf("git config %s: %v\n%s", key, err, out)
-		}
-		if got := strings.TrimSpace(string(out)); got != want {
-			t.Fatalf("%s = %q, want %q", key, got, want)
-		}
-	}
-}

internal/validate/path.go

@@ -17,13 +17,6 @@ func SafeInputPath(path string) (string, error) {
 	return localfileio.SafeInputPath(path)
 }
 
-// LocalInputPath validates a local input path without restricting it to the
-// current working directory. It delegates to localfileio.LocalInputPath so
-// command validation and shared local-file readers use one policy.
-func LocalInputPath(path string) (string, error) {
-	return localfileio.LocalInputPath(path)
-}
-
 // SafeEnvDirPath validates an environment-provided application directory path.
 // Delegates to localfileio.SafeEnvDirPath.
 func SafeEnvDirPath(path, envName string) (string, error) {

internal/validate/path_test.go

@@ -211,18 +211,6 @@ func TestSafeLocalFlagPath(t *testing.T) {
 	}
 }
 
-func TestLocalInputPath_AllowsLocalPathsAndRejectsUnsafeCharacters(t *testing.T) {
-	for _, path := range []string{"/tmp/report.pdf", "../report.pdf"} {
-		got, err := LocalInputPath(path)
-		if err != nil || got != path {
-			t.Fatalf("LocalInputPath(%q) = %q, %v; want unchanged path", path, got, err)
-		}
-	}
-	if _, err := LocalInputPath("report\n.pdf"); err == nil {
-		t.Fatal("LocalInputPath() unexpectedly accepted a control character")
-	}
-}
-
 func TestSafeUploadPath_AllowsTempFileAbsolutePath(t *testing.T) {
 	// GIVEN: a real temp file (absolute path under os.TempDir())
 	f, err := os.CreateTemp("", "upload-test-*.bin")

internal/vfs/localfileio/path.go

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"path/filepath"
 	"strings"
-	"unicode"
 
 	"github.com/larksuite/cli/internal/charcheck"
 	"github.com/larksuite/cli/internal/vfs"
@@ -23,32 +22,6 @@ func SafeInputPath(path string) (string, error) {
 	return safePath(path, "--file")
 }
 
-// LocalInputPath validates an input path in the process local filesystem
-// namespace. It intentionally does not impose cwd containment or canonicalize
-// the path: absolute paths, parent-relative paths, and symlink traversal retain
-// their normal OS semantics. Character validation remains mandatory because
-// paths are user-controlled and may appear in errors or progress output.
-func LocalInputPath(path string) (string, error) {
-	if strings.TrimSpace(path) == "" {
-		return "", fmt.Errorf("local input path must not be empty")
-	}
-	if strings.IndexFunc(path, unicode.IsControl) >= 0 {
-		return "", fmt.Errorf("local input path must not contain control characters")
-	}
-	if err := charcheck.RejectControlChars(path, "local input path"); err != nil {
-		return "", err
-	}
-	if err := validateLocalInputPlatform(path); err != nil {
-		return "", err
-	}
-	return path, nil
-}
-
-func isWindowsNonLocalNamespace(path string) bool {
-	normalized := strings.ReplaceAll(path, "/", `\`)
-	return strings.HasPrefix(normalized, `\\`) || strings.HasPrefix(normalized, `\??\`)
-}
-
 // SafeLocalFlagPath validates a flag value as a local file path.
 // Empty values and http/https URLs are returned unchanged without validation.
 func SafeLocalFlagPath(flagName, value string) (string, error) {
@@ -56,7 +29,7 @@ func SafeLocalFlagPath(flagName, value string) (string, error) {
 		return value, nil
 	}
 	if _, err := SafeInputPath(value); err != nil {
-		return "", fmt.Errorf("%s: %w", flagName, err)
+		return "", fmt.Errorf("%s: %v", flagName, err)
 	}
 	return value, nil
 }

internal/vfs/localfileio/path_local_other.go

@@ -1,8 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-//go:build !windows
-
-package localfileio
-
-func validateLocalInputPlatform(string) error { return nil }

internal/vfs/localfileio/path_local_windows.go

@@ -1,33 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-//go:build windows
-
-package localfileio
-
-import (
-	"fmt"
-	"path/filepath"
-	"strings"
-)
-
-func validateLocalInputPlatform(path string) error {
-	if isWindowsNonLocalNamespace(path) {
-		return fmt.Errorf("local input path must not use a Windows network or device namespace")
-	}
-
-	cleaned := filepath.Clean(path)
-	volume := filepath.VolumeName(cleaned)
-	remainder := strings.TrimLeft(cleaned[len(volume):], `\/`)
-	for _, component := range strings.FieldsFunc(remainder, func(r rune) bool {
-		return r == '\\' || r == '/'
-	}) {
-		if component == "." || component == ".." {
-			continue
-		}
-		if !filepath.IsLocal(component) {
-			return fmt.Errorf("local input path contains a reserved Windows path component %q", component)
-		}
-	}
-	return nil
-}

internal/vfs/localfileio/path_local_windows_test.go

@@ -1,27 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-//go:build windows
-
-package localfileio
-
-import "testing"
-
-func TestLocalInputPath_RejectsWindowsNetworkDeviceAndReservedPaths(t *testing.T) {
-	for _, input := range []string{
-		`\\server\share\report.pdf`,
-		`//server/share/report.pdf`,
-		`\\.\pipe\upload`,
-		`\\?\C:\Users\agent\report.pdf`,
-		`\\?\UNC\server\share\report.pdf`,
-		`\??\C:\Users\agent\report.pdf`,
-		`C:\Users\agent\NUL.txt`,
-		`CON`,
-	} {
-		t.Run(input, func(t *testing.T) {
-			if _, err := LocalInputPath(input); err == nil {
-				t.Fatalf("LocalInputPath(%q) unexpectedly succeeded", input)
-			}
-		})
-	}
-}

internal/vfs/localfileio/path_test.go

@@ -4,7 +4,6 @@
 package localfileio
 
 import (
-	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@@ -72,72 +71,6 @@ func TestSafeOutputPath_RejectsPathTraversalAndDangerousInput(t *testing.T) {
 	}
 }
 
-func TestLocalInputPath_AllowsLocalNamespaceWithoutRewriting(t *testing.T) {
-	for _, input := range []string{
-		"/tmp/report.pdf",
-		"../outside/report.pdf",
-		"./report.pdf",
-		"nested/../report.pdf",
-		`C:\Users\agent\report.pdf`,
-		"报告.pdf",
-	} {
-		t.Run(input, func(t *testing.T) {
-			got, err := LocalInputPath(input)
-			if err != nil {
-				t.Fatalf("LocalInputPath(%q) error = %v", input, err)
-			}
-			if got != input {
-				t.Fatalf("LocalInputPath(%q) = %q, want path preserved verbatim", input, got)
-			}
-		})
-	}
-}
-
-func TestWindowsNonLocalNamespace(t *testing.T) {
-	for _, input := range []string{
-		`\\server\share\report.pdf`,
-		`//server/share/report.pdf`,
-		`\\.\pipe\upload`,
-		`\\?\C:\Users\agent\report.pdf`,
-		`\\?\UNC\server\share\report.pdf`,
-		`\??\C:\Users\agent\report.pdf`,
-	} {
-		if !isWindowsNonLocalNamespace(input) {
-			t.Errorf("isWindowsNonLocalNamespace(%q) = false, want true", input)
-		}
-	}
-
-	for _, input := range []string{
-		`C:\Users\agent\report.pdf`,
-		`C:/Users/agent/report.pdf`,
-		`..\outside\report.pdf`,
-		`.\report.pdf`,
-	} {
-		if isWindowsNonLocalNamespace(input) {
-			t.Errorf("isWindowsNonLocalNamespace(%q) = true, want false", input)
-		}
-	}
-}
-
-func TestLocalInputPath_RejectsEmptyControlAndDangerousUnicode(t *testing.T) {
-	for _, input := range []string{
-		"",
-		"   ",
-		"file\x00.txt",
-		"file\tname.txt",
-		"file\nname.txt",
-		"file\rname.txt",
-		"file\u202Ename.txt",
-		"file\u200Bname.txt",
-	} {
-		t.Run(fmt.Sprintf("%q", input), func(t *testing.T) {
-			if _, err := LocalInputPath(input); err == nil {
-				t.Fatalf("LocalInputPath(%q) unexpectedly succeeded", input)
-			}
-		})
-	}
-}
-
 func TestSafeOutputPath_ReturnsCanonicalAbsolutePath(t *testing.T) {
 	// GIVEN: a clean temp directory as CWD
 	dir := t.TempDir()

lint/errscontract/scan_test.go

@@ -34,12 +34,7 @@ func writeFixture(t *testing.T, files fixtureRepo) string {
 
 func runGit(t *testing.T, root string, args ...string) string {
 	t.Helper()
-	commandArgs := []string{
-		"-c", "maintenance.autoDetach=false",
-		"-c", "gc.autoDetach=false",
-	}
-	commandArgs = append(commandArgs, args...)
-	cmd := exec.Command("git", commandArgs...)
+	cmd := exec.Command("git", args...)
 	cmd.Dir = root
 	out, err := cmd.CombinedOutput()
 	if err != nil {
@@ -48,14 +43,6 @@ func runGit(t *testing.T, root string, args ...string) string {
 	return strings.TrimSpace(string(out))
 }
 
-func TestRunGitDisablesDetachedMaintenance(t *testing.T) {
-	for _, key := range []string{"maintenance.autoDetach", "gc.autoDetach"} {
-		if got := runGit(t, t.TempDir(), "config", "--get", "--type=bool", key); got != "false" {
-			t.Fatalf("%s = %q, want false", key, got)
-		}
-	}
-}
-
 func TestLoadSubtypeAllowlist_ExtractsTypedConstValues(t *testing.T) {
 	root := writeFixture(t, fixtureRepo{
 		"errs/subtypes.go": `package errs

package-lock.json

@@ -1,16 +1,15 @@
 {
   "name": "@larksuite/cli",
-  "version": "1.0.78-beta.10",
+  "version": "1.0.73-beta.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@larksuite/cli",
-      "version": "1.0.78-beta.10",
+      "version": "1.0.73-beta.2",
       "cpu": [
         "x64",
-        "arm64",
-        "riscv64"
+        "arm64"
       ],
       "hasInstallScript": true,
       "license": "MIT",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@larksuite/cli",
-  "version": "1.0.78-beta.10",
+  "version": "1.0.73-beta.2",
   "description": "The official CLI for Lark/Feishu open platform",
   "bin": {
     "lark-cli": "scripts/run.js"

scripts/install.js

@@ -7,7 +7,7 @@ const { execFileSync } = require("child_process");
 const os = require("os");
 const crypto = require("crypto");
 
-const VERSION = require("../package.json").version;
+const VERSION = require("../package.json").version.replace(/-.*$/, "");
 const REPO = "larksuite/cli";
 const NAME = "lark-cli";
 const DEFAULT_MIRROR_HOST = "https://registry.npmmirror.com";
@@ -37,26 +37,13 @@ const platform = PLATFORM_MAP[process.platform];
 const arch = ARCH_MAP[process.arch];
 
 const isWindows = process.platform === "win32";
-const { archiveName, githubUrl: GITHUB_URL } = resolveReleaseAsset(
-  VERSION,
-  platform,
-  arch
-);
+const ext = isWindows ? ".zip" : ".tar.gz";
+const archiveName = `${NAME}-${VERSION}-${platform}-${arch}${ext}`;
+const GITHUB_URL = `https://github.com/${REPO}/releases/download/v${VERSION}/${archiveName}`;
 
 const binDir = path.join(__dirname, "..", "bin");
 const dest = path.join(binDir, NAME + (isWindows ? ".exe" : ""));
 
-function resolveReleaseAsset(version, platformName, archName) {
-  const extension = platformName === "windows" ? ".zip" : ".tar.gz";
-  const resolvedArchiveName =
-    `${NAME}-${version}-${platformName}-${archName}${extension}`;
-  return {
-    archiveName: resolvedArchiveName,
-    githubUrl:
-      `https://github.com/${REPO}/releases/download/v${version}/${resolvedArchiveName}`,
-  };
-}
-
 // Build the ordered list of binary mirror URLs to try. Resolution rules:
 //   1. npm_config_registry     — when the user has set a non-default
 //                                registry (npmmirror clone, corp Verdaccio,
@@ -361,4 +348,4 @@ if (require.main === module) {
   }
 }
 
-module.exports = { getExpectedChecksum, verifyChecksum, assertAllowedHost, resolveMirrorUrls, resolveReleaseAsset, curlSupportsSslRevokeBestEffort, isCurlVersionSupported };
+module.exports = { getExpectedChecksum, verifyChecksum, assertAllowedHost, resolveMirrorUrls, curlSupportsSslRevokeBestEffort, isCurlVersionSupported };

scripts/install.test.js

@@ -9,36 +9,7 @@ const os = require("os");
 
 const crypto = require("crypto");
 
-const {
-  getExpectedChecksum,
-  verifyChecksum,
-  assertAllowedHost,
-  resolveMirrorUrls,
-  resolveReleaseAsset,
-  isCurlVersionSupported,
-} = require("./install.js");
-
-describe("resolveReleaseAsset", () => {
-  it("preserves a beta package version in tag and archive paths", () => {
-    const asset = resolveReleaseAsset(
-      "1.2.0-beta.1",
-      "linux",
-      "amd64"
-    );
-
-    assert.deepEqual(asset, {
-      archiveName: "lark-cli-1.2.0-beta.1-linux-amd64.tar.gz",
-      githubUrl:
-        "https://github.com/larksuite/cli/releases/download/v1.2.0-beta.1/lark-cli-1.2.0-beta.1-linux-amd64.tar.gz",
-    });
-    assert.deepEqual(
-      resolveMirrorUrls({}, asset.archiveName, "1.2.0-beta.1"),
-      [
-        "https://registry.npmmirror.com/-/binary/lark-cli/v1.2.0-beta.1/lark-cli-1.2.0-beta.1-linux-amd64.tar.gz",
-      ]
-    );
-  });
-});
+const { getExpectedChecksum, verifyChecksum, assertAllowedHost, resolveMirrorUrls, isCurlVersionSupported } = require("./install.js");
 
 describe("getExpectedChecksum", () => {
   function makeTmpChecksums(content) {

scripts/release-preflight.js

@@ -5,13 +5,12 @@
 const fs = require("node:fs");
 const path = require("node:path");
 
-const RELEASE_VERSION_PATTERN = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(?:-beta\.(0|[1-9][0-9]*))?$/;
+const STABLE_VERSION_PATTERN = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$/;
+const REHEARSAL_VERSION_PATTERN = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)-beta\.(0|[1-9][0-9]*)$/;
 
-function releaseChannelOf(value) {
-  if (typeof value !== "string" || !RELEASE_VERSION_PATTERN.test(value)) {
-    return null;
-  }
-  return value.includes("-beta.") ? "beta" : "stable";
+function isReleaseVersion(value) {
+  return typeof value === "string" &&
+    (STABLE_VERSION_PATTERN.test(value) || REHEARSAL_VERSION_PATTERN.test(value));
 }
 
 function releaseError(message, observed, hint) {
@@ -34,11 +33,11 @@ function validateReleasePreflight(packageJson, packageLockJson, tag) {
     ["package-lock.json.version", lockVersion],
     ['package-lock.json.packages[""].version', lockRootVersion],
   ]) {
-    if (!releaseChannelOf(value)) {
+    if (!isReleaseVersion(value)) {
       return releaseError(
-        `${field} must be a Stable or Beta release version`,
+        `${field} must use X.Y.Z or the rehearsal form X.Y.Z-beta.N`,
         observed,
-        "Use the same stable X.Y.Z or beta X.Y.Z-beta.N version in all package fields; other prerelease labels and build metadata are not allowed.",
+        "Use the same version in all package fields; only stable releases and the temporary beta rehearsal form are allowed.",
       );
     }
   }
@@ -51,15 +50,14 @@ function validateReleasePreflight(packageJson, packageLockJson, tag) {
     );
   }
 
-  const releaseChannel = releaseChannelOf(packageVersion);
   if (tag === undefined) {
-    return { ok: true, data: { ...observed, releaseChannel } };
+    return { ok: true, data: observed };
   }
-  if (typeof tag !== "string" || !tag.startsWith("v") || !releaseChannelOf(tag.slice(1))) {
+  if (typeof tag !== "string" || !tag.startsWith("v") || !isReleaseVersion(tag.slice(1))) {
     return releaseError(
-      "--tag must use a Stable or Beta release form",
+      "--tag must use vX.Y.Z or the rehearsal form vX.Y.Z-beta.N",
       { ...observed, tag },
-      `Use --tag v${packageVersion}; valid forms are vX.Y.Z and vX.Y.Z-beta.N.`,
+      `Use --tag v${packageVersion}.`,
     );
   }
 
@@ -71,7 +69,7 @@ function validateReleasePreflight(packageJson, packageLockJson, tag) {
       `Use --tag v${packageVersion}.`,
     );
   }
-  return { ok: true, data: { ...observed, tagVersion, releaseChannel } };
+  return { ok: true, data: { ...observed, tagVersion } };
 }
 
 function writeResult(result) {
@@ -86,7 +84,7 @@ function main() {
     tag = args[1];
   } else if (args.length !== 0) {
     writeResult(releaseError(
-      "Expected no arguments or --tag vX.Y.Z[-beta.N]",
+      "Expected no arguments or --tag vX.Y.Z",
       { arguments: args },
       "Run release:check without arguments or pass exactly one --tag value.",
     ));

scripts/release-preflight.test.js

@@ -2,11 +2,192 @@
 // SPDX-License-Identifier: MIT
 
 const assert = require("node:assert/strict");
+const { spawnSync } = require("node:child_process");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
 const { describe, it } = require("node:test");
 
-const { validateReleasePreflight } = require("./release-preflight");
+const {
+  validateReleasePreflight,
+} = require("./release-preflight");
 
-function metadata(version = "1.2.3") {
+const repoRoot = path.resolve(__dirname, "..");
+
+function createReleaseFixture(t, env = {}) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "tag-release-test-"));
+  const scriptsDir = path.join(root, "scripts");
+  const binDir = path.join(root, "bin");
+  const stateDir = path.join(root, "state");
+  const logPath = path.join(root, "git-calls.jsonl");
+  const npmLogPath = path.join(root, "npm-calls.jsonl");
+  fs.mkdirSync(scriptsDir);
+  fs.mkdirSync(binDir);
+  fs.mkdirSync(stateDir);
+  fs.copyFileSync(
+    path.join(repoRoot, "scripts/release-preflight.js"),
+    path.join(scriptsDir, "release-preflight.js"),
+  );
+  fs.copyFileSync(
+    path.join(repoRoot, "scripts/tag-release.sh"),
+    path.join(scriptsDir, "tag-release.sh"),
+  );
+  fs.writeFileSync(path.join(root, "package.json"), '{"version":"1.2.3-beta.0"}\n');
+  fs.writeFileSync(
+    path.join(root, "package-lock.json"),
+    '{"version":"1.2.3-beta.0","packages":{"":{"version":"1.2.3-beta.0"}}}\n',
+  );
+
+  const fakeGitPath = path.join(binDir, "git");
+  fs.writeFileSync(fakeGitPath, String.raw`#!/usr/bin/env node
+const fs = require("node:fs");
+const path = require("node:path");
+
+const args = process.argv.slice(2);
+const stateDir = process.env.FAKE_GIT_STATE_DIR;
+const localTagPath = path.join(stateDir, "local-tag");
+if (process.cwd() !== process.env.FAKE_EXPECTED_GIT_CWD) {
+  process.stderr.write("git invoked outside repository root: " + process.cwd() + "\n");
+  process.exit(96);
+}
+fs.appendFileSync(process.env.FAKE_GIT_LOG, JSON.stringify(args) + "\n");
+
+function print(value) {
+  process.stdout.write(value + "\n");
+}
+
+switch (args[0]) {
+  case "branch":
+    print(process.env.FAKE_BRANCH || "test/npm-staged-publish-rehearsal");
+    break;
+  case "status":
+    if (process.env.FAKE_STATUS_OUTPUT) print(process.env.FAKE_STATUS_OUTPUT);
+    break;
+  case "fetch":
+    break;
+  case "rev-parse": {
+    const ref = args[args.length - 1];
+    if (ref === "HEAD") {
+      print(process.env.FAKE_HEAD_SHA);
+      break;
+    }
+    if (ref === "FETCH_HEAD^{commit}") {
+      print(process.env.FAKE_REHEARSAL_SHA);
+      break;
+    }
+    if (ref.startsWith("refs/tags/")) {
+      if (fs.existsSync(localTagPath)) {
+        print(fs.readFileSync(localTagPath, "utf8").trim());
+        break;
+      }
+      process.exit(1);
+    }
+    process.stderr.write("unexpected rev-parse ref: " + ref + "\n");
+    process.exit(97);
+    break;
+  }
+  case "ls-remote": {
+    const tagRef = args.find((arg) => arg.startsWith("refs/tags/") && !arg.endsWith("^{}"));
+    const kind = process.env.FAKE_REMOTE_TAG_KIND || "absent";
+    if (kind === "lightweight" || kind === "annotated") {
+      print(process.env.FAKE_REMOTE_TAG_SHA + "\t" + tagRef);
+    }
+    break;
+  }
+  case "show":
+    print(process.env.FAKE_WORKFLOW);
+    break;
+  case "tag":
+    fs.writeFileSync(localTagPath, args[2] || process.env.FAKE_HEAD_SHA);
+    break;
+  case "push": {
+    const failedMarker = path.join(stateDir, "push-failed");
+    if (process.env.FAKE_PUSH_FAIL_ONCE && !fs.existsSync(failedMarker)) {
+      fs.writeFileSync(failedMarker, "1");
+      process.exit(Number(process.env.FAKE_PUSH_FAIL_ONCE));
+    }
+    break;
+  }
+  default:
+    process.stderr.write("unexpected git command: " + args.join(" ") + "\n");
+    process.exit(97);
+}
+`);
+  fs.chmodSync(fakeGitPath, 0o755);
+
+  const fakeNpmPath = path.join(binDir, "npm");
+  fs.writeFileSync(fakeNpmPath, String.raw`#!/usr/bin/env node
+const fs = require("node:fs");
+const args = process.argv.slice(2);
+fs.appendFileSync(process.env.FAKE_NPM_LOG, JSON.stringify(args) + "\n");
+if (args[0] !== "view") {
+  process.stderr.write("unexpected npm command: " + args.join(" ") + "\n");
+  process.exit(97);
+}
+const output = process.env.FAKE_NPM_VIEW_OUTPUT || "npm error code E404\nnpm error 404 Not Found";
+(Number(process.env.FAKE_NPM_VIEW_STATUS || "1") === 0 ? process.stdout : process.stderr).write(output + "\n");
+process.exit(Number(process.env.FAKE_NPM_VIEW_STATUS || "1"));
+`);
+  fs.chmodSync(fakeNpmPath, 0o755);
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+
+  return {
+    root,
+    stateDir,
+    logPath,
+    env: {
+      ...process.env,
+      PATH: `${binDir}${path.delimiter}${process.env.PATH}`,
+      LANG: "C",
+      LC_ALL: "C",
+      FAKE_GIT_LOG: logPath,
+      FAKE_NPM_LOG: npmLogPath,
+      FAKE_GIT_STATE_DIR: stateDir,
+      FAKE_EXPECTED_GIT_CWD: fs.realpathSync(root),
+      FAKE_HEAD_SHA: "aaaaaaaa",
+      FAKE_REHEARSAL_SHA: "aaaaaaaa",
+      FAKE_WORKFLOW: "args: release --clean --skip=publish\nrun: npm stage publish package.tgz --access public --tag beta",
+      ...env,
+    },
+  };
+}
+
+function runTagRelease(fixture, options = {}) {
+  const { cwd = fixture.root, args = [], input = "" } = options;
+  return spawnSync("bash", [path.join(fixture.root, "scripts/tag-release.sh"), ...args], {
+    cwd,
+    env: fixture.env,
+    encoding: "utf8",
+    input,
+  });
+}
+
+function readGitCalls(fixture) {
+  if (!fs.existsSync(fixture.logPath)) {
+    return [];
+  }
+  return fs.readFileSync(fixture.logPath, "utf8")
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => JSON.parse(line));
+}
+
+function assertNoTagOperations(calls) {
+  const tagOperations = calls.filter((args) =>
+    args[0] === "ls-remote" ||
+    args[0] === "tag" ||
+    args[0] === "push" ||
+    (args[0] === "rev-parse" && args.some((arg) => arg.startsWith("refs/tags/"))),
+  );
+  assert.deepEqual(tagOperations, []);
+}
+
+function assertNoTagWrites(calls) {
+  assert.equal(calls.some((args) => args[0] === "tag" || args[0] === "push"), false);
+}
+
+function validInputs(version = "1.2.3") {
   return {
     packageJson: { version },
     packageLockJson: {
@@ -16,124 +197,415 @@ function metadata(version = "1.2.3") {
   };
 }
 
-function assertRejected(result) {
+function assertStructuredError(result) {
   assert.equal(result.ok, false);
   assert.equal(result.error.type, "release_preflight");
   assert.equal(typeof result.error.message, "string");
+  assert.ok(result.error.message.length > 0);
+  assert.equal(typeof result.error.observed, "object");
+  assert.equal(typeof result.error.hint, "string");
+  assert.ok(result.error.hint.length > 0);
+}
+
+function assertInOrder(source, snippets) {
+  let previous = -1;
+  for (const snippet of snippets) {
+    const index = source.indexOf(snippet);
+    assert.ok(index >= 0, `missing fragment: ${snippet}`);
+    assert.ok(index > previous, `fragment is out of order: ${snippet}`);
+    previous = index;
+  }
 }
 
 describe("validateReleasePreflight", () => {
-  it("accepts matching stable package, lock, and tag versions", () => {
-    const { packageJson, packageLockJson } = metadata();
+  it("accepts matching stable and beta rehearsal versions", () => {
+    for (const version of ["1.2.3", "1.2.3-beta.0"]) {
+      const { packageJson, packageLockJson } = validInputs(version);
 
-    assert.deepEqual(
-      validateReleasePreflight(packageJson, packageLockJson, "v1.2.3"),
-      {
+      assert.deepEqual(validateReleasePreflight(packageJson, packageLockJson), {
         ok: true,
         data: {
-          packageVersion: "1.2.3",
-          lockVersion: "1.2.3",
-          lockRootVersion: "1.2.3",
-          tagVersion: "1.2.3",
-          releaseChannel: "stable",
-        },
-      },
-    );
-  });
-
-  it("accepts matching beta package, lock, and tag versions", () => {
-    const { packageJson, packageLockJson } = metadata("1.2.3-beta.4");
-
-    assert.deepEqual(
-      validateReleasePreflight(packageJson, packageLockJson, "v1.2.3-beta.4"),
-      {
-        ok: true,
-        data: {
-          packageVersion: "1.2.3-beta.4",
-          lockVersion: "1.2.3-beta.4",
-          lockRootVersion: "1.2.3-beta.4",
-          tagVersion: "1.2.3-beta.4",
-          releaseChannel: "beta",
-        },
-      },
-    );
-  });
-
-  it("derives the release channel when no tag is provided", () => {
-    const { packageJson, packageLockJson } = metadata("1.2.3-beta.0");
-
-    assert.deepEqual(
-      validateReleasePreflight(packageJson, packageLockJson),
-      {
-        ok: true,
-        data: {
-          packageVersion: "1.2.3-beta.0",
-          lockVersion: "1.2.3-beta.0",
-          lockRootVersion: "1.2.3-beta.0",
+          packageVersion: version,
+          lockVersion: version,
+          lockRootVersion: version,
           tagVersion: null,
-          releaseChannel: "beta",
         },
-      },
+      });
+      assert.deepEqual(
+        validateReleasePreflight(packageJson, packageLockJson, `v${version}`),
+        {
+          ok: true,
+          data: {
+            packageVersion: version,
+            lockVersion: version,
+            lockRootVersion: version,
+            tagVersion: version,
+          },
+        },
+      );
+    }
+  });
+
+  it("rejects prerelease forms other than beta rehearsal versions", () => {
+    const { packageJson, packageLockJson } = validInputs("1.2.3-rc.1");
+
+    const result = validateReleasePreflight(packageJson, packageLockJson);
+
+    assertStructuredError(result);
+    assert.equal(
+      result.error.message,
+      "package.json.version must use X.Y.Z or the rehearsal form X.Y.Z-beta.N",
+    );
+    assert.equal(
+      result.error.hint,
+      "Use the same version in all package fields; only stable releases and the temporary beta rehearsal form are allowed.",
     );
   });
 
-  it("rejects unsupported or invalid package versions with an actionable hint", () => {
-    for (const version of [
-      "1.2.3-alpha.1",
-      "1.2.3-rc.1",
-      "1.2.3-beta",
-      "1.2.3-beta.01",
-      "1.2.3+build.1",
-      "1.2.3-beta.1+build.1",
-      "01.2.3",
-      "1.02.3",
-      "1.2.03",
-    ]) {
-      const { packageJson, packageLockJson } = metadata(version);
-      const result = validateReleasePreflight(packageJson, packageLockJson);
+  it("rejects build metadata package versions with the stable release contract", () => {
+    const { packageJson, packageLockJson } = validInputs("1.2.3+build.7");
 
-      assertRejected(result);
-      assert.match(result.error.hint, /stable X\.Y\.Z or beta X\.Y\.Z-beta\.N/i);
+    const result = validateReleasePreflight(packageJson, packageLockJson);
+
+    assertStructuredError(result);
+    assert.equal(
+      result.error.message,
+      "package.json.version must use X.Y.Z or the rehearsal form X.Y.Z-beta.N",
+    );
+    assert.equal(
+      result.error.hint,
+      "Use the same version in all package fields; only stable releases and the temporary beta rehearsal form are allowed.",
+    );
+  });
+
+  it("rejects invalid and missing package or lock SemVer values", () => {
+    const invalid = validInputs();
+    invalid.packageJson.version = "01.2.3";
+    const missing = validInputs();
+    delete missing.packageLockJson.packages[""].version;
+
+    for (const result of [
+      validateReleasePreflight(invalid.packageJson, invalid.packageLockJson),
+      validateReleasePreflight(missing.packageJson, missing.packageLockJson),
+    ]) {
+      assertStructuredError(result);
     }
   });
 
-  it("rejects inconsistent package metadata", () => {
-    const topLevelMismatch = metadata();
-    topLevelMismatch.packageLockJson.version = "1.2.4";
-    const rootMismatch = metadata();
-    rootMismatch.packageLockJson.packages[""].version = "1.2.4";
-    const channelMismatch = metadata("1.2.3-beta.1");
-    channelMismatch.packageLockJson.version = "1.2.3";
+  it("rejects a top-level package-lock version mismatch", () => {
+    const { packageJson, packageLockJson } = validInputs();
+    packageLockJson.version = "1.2.4";
 
-    for (const { packageJson, packageLockJson } of [
-      topLevelMismatch,
-      rootMismatch,
-      channelMismatch,
-    ]) {
-      assertRejected(validateReleasePreflight(packageJson, packageLockJson));
-    }
+    const result = validateReleasePreflight(packageJson, packageLockJson);
+
+    assertStructuredError(result);
+    assert.deepEqual(result.error.observed, {
+      packageVersion: "1.2.3",
+      lockVersion: "1.2.4",
+      lockRootVersion: "1.2.3",
+      tagVersion: null,
+    });
   });
 
-  it("rejects an invalid or mismatched release tag", () => {
-    const { packageJson, packageLockJson } = metadata();
+  it("rejects a package-lock root package version mismatch", () => {
+    const { packageJson, packageLockJson } = validInputs();
+    packageLockJson.packages[""].version = "1.2.4";
 
-    for (const tag of [
-      "1.2.3",
-      "v1.2.3-alpha.1",
-      "v1.2.3-beta.01",
-      "v1.2.3+build.1",
-      "v1.2.3-beta.1",
-      "v1.2.4",
-    ]) {
-      assertRejected(validateReleasePreflight(packageJson, packageLockJson, tag));
-    }
+    const result = validateReleasePreflight(packageJson, packageLockJson);
+
+    assertStructuredError(result);
+    assert.deepEqual(result.error.observed, {
+      packageVersion: "1.2.3",
+      lockVersion: "1.2.3",
+      lockRootVersion: "1.2.4",
+      tagVersion: null,
+    });
   });
 
-  it("rejects a beta tag that does not match beta package metadata", () => {
-    const { packageJson, packageLockJson } = metadata("1.2.3-beta.2");
+  it("rejects invalid and mismatched tags", () => {
+    const { packageJson, packageLockJson } = validInputs();
 
-    for (const tag of ["v1.2.3-beta.1", "v1.2.3"]) {
-      assertRejected(validateReleasePreflight(packageJson, packageLockJson, tag));
+    for (const tag of ["1.2.3", "v01.2.3", "v1.2.4"]) {
+      const result = validateReleasePreflight(packageJson, packageLockJson, tag);
+      assertStructuredError(result);
+      assert.equal(result.error.observed.tag, tag);
     }
   });
 });
+
+describe("release configuration", () => {
+  it("writes success to stdout and structured failures to stderr", () => {
+    const scriptPath = path.join(repoRoot, "scripts/release-preflight.js");
+    const packageVersion = require(path.join(repoRoot, "package.json")).version;
+    const success = spawnSync(process.execPath, [scriptPath, "--tag", `v${packageVersion}`], {
+      cwd: repoRoot,
+      encoding: "utf8",
+    });
+    const failure = spawnSync(process.execPath, [scriptPath, "--tag", "invalid"], {
+      cwd: repoRoot,
+      encoding: "utf8",
+    });
+
+    assert.equal(success.status, 0);
+    assert.equal(success.stderr, "");
+    assert.deepEqual(JSON.parse(success.stdout), {
+      ok: true,
+      data: {
+        packageVersion,
+        lockVersion: packageVersion,
+        lockRootVersion: packageVersion,
+        tagVersion: packageVersion,
+      },
+    });
+    assert.equal(failure.status, 1);
+    assert.equal(failure.stdout, "");
+    assertStructuredError(JSON.parse(failure.stderr));
+  });
+
+  it("keeps package metadata synchronized without changing the Node engine", () => {
+    const packageJson = require(path.join(repoRoot, "package.json"));
+    const packageLockJson = require(path.join(repoRoot, "package-lock.json"));
+
+    assert.equal(packageJson.scripts["release:check"], "node scripts/release-preflight.js");
+    assert.equal(packageJson.engines.node, ">=16");
+    assert.equal(packageLockJson.version, packageJson.version);
+    assert.equal(packageLockJson.packages[""].version, packageJson.version);
+  });
+
+  it("runs every release gate before any tag query, creation, or push", () => {
+    const script = fs.readFileSync(path.join(repoRoot, "scripts/tag-release.sh"), "utf8");
+    const preflight = script.indexOf('node "${SCRIPT_DIR}/release-preflight.js" --tag "${TAG}"');
+    const requiredGates = [
+      'CURRENT_BRANCH=$(git branch --show-current)',
+      'git status --porcelain',
+      'git fetch origin "${REHEARSAL_BRANCH}"',
+      'git rev-parse "FETCH_HEAD^{commit}"',
+      'git show "${HEAD_SHA}:.github/workflows/release.yml"',
+      'npm view "@larksuite/cli@${VERSION}" version',
+    ];
+    const tagOperations = [
+      'git rev-parse -q --verify "refs/tags/${TAG}"',
+      'git ls-remote --tags origin "refs/tags/${TAG}"',
+      'git tag "${TAG}" "${HEAD_SHA}"',
+      'git push origin "refs/tags/${TAG}:refs/tags/${TAG}"',
+    ];
+
+    assert.ok(preflight >= 0, "release preflight invocation is missing");
+    assertInOrder(script, [
+      'REPO_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"',
+      'cd "${REPO_ROOT}"',
+      'node "${SCRIPT_DIR}/release-preflight.js"',
+    ]);
+    assert.equal(script.includes("require('${REPO_ROOT}/package.json')"), false);
+    for (const gate of requiredGates) {
+      const index = script.indexOf(gate);
+      assert.ok(index >= 0, `required release gate is missing: ${gate}`);
+      assert.ok(index < script.indexOf(tagOperations[0]), `${gate} must run before tag queries`);
+    }
+    for (const operation of tagOperations) {
+      const index = script.indexOf(operation);
+      assert.ok(index >= 0, `tag operation is missing: ${operation}`);
+      assert.ok(preflight < index, `preflight must run before: ${operation}`);
+    }
+    assertInOrder(script, [
+      'if [ "${PUSH_TAG}" != true ]',
+      'read -r CONFIRM_TAG',
+      'git tag "${TAG}" "${HEAD_SHA}"',
+      'git push origin "refs/tags/${TAG}:refs/tags/${TAG}"',
+    ]);
+  });
+});
+
+describe("tag-release.sh behavior", () => {
+  it("runs repository checks from the script repository when invoked elsewhere", (t) => {
+    const fixture = createReleaseFixture(t);
+    const outside = fs.mkdtempSync(path.join(os.tmpdir(), "tag-release-cwd-"));
+    t.after(() => fs.rmSync(outside, { recursive: true, force: true }));
+
+    const result = runTagRelease(fixture, { cwd: outside });
+
+    assert.equal(result.status, 0, result.stderr);
+  });
+
+  it("rejects a non-rehearsal branch before querying or modifying tags", (t) => {
+    const fixture = createReleaseFixture(t, { FAKE_BRANCH: "feature/release" });
+
+    const result = runTagRelease(fixture);
+    const calls = readGitCalls(fixture);
+
+    assert.equal(result.status, 1);
+    assert.match(result.stderr, /must be created from test\/npm-staged-publish-rehearsal/i);
+    assertNoTagOperations(calls);
+  });
+
+  it("rejects a dirty working tree before tag operations", (t) => {
+    const fixture = createReleaseFixture(t, { FAKE_STATUS_OUTPUT: " M README.md" });
+    const result = runTagRelease(fixture);
+    const calls = readGitCalls(fixture);
+
+    assert.equal(result.status, 1);
+    assert.match(result.stderr, /working tree must be clean/i);
+    assertNoTagOperations(calls);
+  });
+
+  it("rejects HEAD that differs from the fetched rehearsal branch", (t) => {
+    const fixture = createReleaseFixture(t, { FAKE_REHEARSAL_SHA: "bbbbbbbb" });
+
+    const result = runTagRelease(fixture);
+    const calls = readGitCalls(fixture);
+
+    assert.equal(result.status, 1);
+    assert.match(result.stderr, /HEAD must exactly match origin\/test\/npm-staged-publish-rehearsal/i);
+    assertNoTagOperations(calls);
+  });
+
+  it("compares HEAD with the exact fetched rehearsal commit", (t) => {
+    const fixture = createReleaseFixture(t);
+
+    const result = runTagRelease(fixture);
+    const calls = readGitCalls(fixture);
+
+    assert.equal(result.status, 0, result.stderr);
+    assert.ok(calls.some((args) => args.join(" ") === "fetch origin test/npm-staged-publish-rehearsal"));
+    assert.ok(calls.some((args) => args.join(" ") === "rev-parse FETCH_HEAD^{commit}"));
+    assert.equal(calls.some((args) => args.includes("origin/test/npm-staged-publish-rehearsal")), false);
+  });
+
+  it("fails when the local tag already exists", (t) => {
+    const fixture = createReleaseFixture(t);
+    fs.writeFileSync(path.join(fixture.stateDir, "local-tag"), "bbbbbbbb");
+
+    const result = runTagRelease(fixture);
+    const calls = readGitCalls(fixture);
+
+    assert.equal(result.status, 1);
+    assert.match(result.stderr, /local tag .* already exists/i);
+    assert.equal(calls.some((args) => args[0] === "ls-remote"), false);
+    assert.equal(calls.some((args) => args[0] === "push"), false);
+  });
+
+  it("fails when a lightweight or annotated remote tag already exists", (t) => {
+    for (const kind of ["lightweight", "annotated"]) {
+      const fixture = createReleaseFixture(t, {
+        FAKE_REMOTE_TAG_KIND: kind,
+        FAKE_REMOTE_TAG_SHA: "aaaaaaaa",
+      });
+
+      const result = runTagRelease(fixture);
+      const calls = readGitCalls(fixture);
+
+      assert.equal(result.status, 1, `${kind}: ${result.stderr}`);
+      assert.match(result.stderr, /remote tag .* already exists/i);
+      assert.equal(calls.some((args) => args[0] === "tag"), false);
+      assert.equal(calls.some((args) => args[0] === "push"), false);
+    }
+  });
+
+  it("check mode completes without creating or pushing a tag", (t) => {
+    const fixture = createReleaseFixture(t);
+
+    const result = runTagRelease(fixture);
+    const calls = readGitCalls(fixture);
+
+    assert.equal(result.status, 0, result.stderr);
+    assert.match(result.stdout, /No tag was created or pushed/);
+    assertNoTagWrites(calls);
+  });
+
+  it("rejects a production version before invoking git", (t) => {
+    const fixture = createReleaseFixture(t);
+    fs.writeFileSync(path.join(fixture.root, "package.json"), '{"version":"1.2.3"}\n');
+    fs.writeFileSync(
+      path.join(fixture.root, "package-lock.json"),
+      '{"version":"1.2.3","packages":{"":{"version":"1.2.3"}}}\n',
+    );
+
+    const result = runTagRelease(fixture);
+
+    assert.equal(result.status, 1);
+    assert.match(result.stderr, /require an X\.Y\.Z-beta\.N version/);
+    assert.deepEqual(readGitCalls(fixture), []);
+  });
+
+  it("rejects a workflow that can publish live", (t) => {
+    for (const workflow of [
+      "args: release --clean --skip=publish\nrun: npm publish --access public",
+      "args: release --clean --skip=publish\nrun: npm stage publish package.tgz --access public --tag beta\nrun: gh release create v1.2.3-beta.0",
+      "args: release --clean --skip=publish\npermissions:\n  contents: write\nrun: npm stage publish package.tgz --access public --tag beta",
+      "args: release --clean --skip=publish\nenv:\n  GITHUB_TOKEN: ${{ github.token }}\nrun: npm stage publish package.tgz --access public --tag beta",
+    ]) {
+      const fixture = createReleaseFixture(t, { FAKE_WORKFLOW: workflow });
+      const result = runTagRelease(fixture);
+
+      assert.equal(result.status, 1);
+      assert.match(result.stderr, /must be stage-only/i);
+      assertNoTagWrites(readGitCalls(fixture));
+    }
+  });
+
+  it("fails closed when npm cannot prove that the version is unused", (t) => {
+    const fixture = createReleaseFixture(t, {
+      FAKE_NPM_VIEW_OUTPUT: "npm error code ETIMEDOUT",
+    });
+
+    const result = runTagRelease(fixture);
+
+    assert.equal(result.status, 1);
+    assert.match(result.stderr, /npm version lookup failed/i);
+    assertNoTagWrites(readGitCalls(fixture));
+  });
+
+  it("rejects an existing npm version", (t) => {
+    const fixture = createReleaseFixture(t, {
+      FAKE_NPM_VIEW_STATUS: "0",
+      FAKE_NPM_VIEW_OUTPUT: "1.2.3-beta.0",
+    });
+
+    const result = runTagRelease(fixture);
+
+    assert.equal(result.status, 1);
+    assert.match(result.stderr, /already exists on npm/i);
+    assertNoTagWrites(readGitCalls(fixture));
+  });
+
+  it("requires the full tag confirmation in push mode", (t) => {
+    const fixture = createReleaseFixture(t);
+
+    const result = runTagRelease(fixture, { args: ["--push"], input: "no\n" });
+
+    assert.equal(result.status, 1);
+    assert.match(result.stderr, /confirmation did not exactly match/i);
+    assertNoTagWrites(readGitCalls(fixture));
+  });
+
+  it("pushes only the exact confirmed tag ref", (t) => {
+    const fixture = createReleaseFixture(t);
+
+    const result = runTagRelease(fixture, {
+      args: ["--push"],
+      input: "v1.2.3-beta.0\n",
+    });
+    const calls = readGitCalls(fixture);
+
+    assert.equal(result.status, 0, result.stderr);
+    assert.ok(calls.some((args) => args.join(" ") === "tag v1.2.3-beta.0 aaaaaaaa"));
+    assert.ok(calls.some((args) =>
+      args.join(" ") === "push origin refs/tags/v1.2.3-beta.0:refs/tags/v1.2.3-beta.0"));
+    assert.equal(
+      calls.some((args) => args[0] === "push" && args.includes("--tags")),
+      false,
+    );
+  });
+
+  it("reports an invalid package version before invoking git", (t) => {
+    const fixture = createReleaseFixture(t);
+    fs.writeFileSync(path.join(fixture.root, "package.json"), '{"version":"01.2.3"}\n');
+
+    const result = runTagRelease(fixture);
+
+    assert.equal(result.status, 1);
+    assert.equal(result.stdout, "");
+    assertStructuredError(JSON.parse(result.stderr));
+    assert.deepEqual(readGitCalls(fixture), []);
+  });
+});

scripts/release-workflow.test.js

@@ -0,0 +1,168 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const { describe, it } = require("node:test");
+
+const repoRoot = path.resolve(__dirname, "..");
+const releaseWorkflow = fs.readFileSync(
+  path.join(repoRoot, ".github/workflows/release.yml"),
+  "utf8",
+);
+const previewWorkflow = fs.readFileSync(
+  path.join(repoRoot, ".github/workflows/pkg-pr-new.yml"),
+  "utf8",
+);
+function topLevelBlock(source, name) {
+  const match = source.match(
+    new RegExp(
+      `^${name}:\\n([\\s\\S]*?)(?=^[A-Za-z][A-Za-z0-9_-]*:|(?![\\s\\S]))`,
+      "m",
+    ),
+  );
+  assert.ok(match, `missing top-level ${name} block`);
+  return match[0];
+}
+
+function jobBlock(source, name) {
+  const jobs = topLevelBlock(source, "jobs");
+  const match = jobs.match(
+    new RegExp(
+      `^  ${name}:\\n([\\s\\S]*?)(?=^  [A-Za-z][A-Za-z0-9_-]*:|(?![\\s\\S]))`,
+      "m",
+    ),
+  );
+  assert.ok(match, `missing ${name} job`);
+  return match[0];
+}
+
+function assertInOrder(source, snippets) {
+  let previous = -1;
+  for (const snippet of snippets) {
+    const index = source.indexOf(snippet);
+    assert.ok(index >= 0, `missing workflow fragment: ${snippet}`);
+    assert.ok(index > previous, `workflow fragment is out of order: ${snippet}`);
+    previous = index;
+  }
+}
+
+function permissionLines(job) {
+  const match = job.match(/^    permissions:\n((?:      .+\n)+)/m);
+  assert.ok(match, "missing job permissions");
+  return match[1].trim().split("\n").map((line) => line.trim()).sort();
+}
+
+describe("release workflow contract", () => {
+  it("has only the version-tag production trigger", () => {
+    const trigger = topLevelBlock(releaseWorkflow, "on");
+
+    assert.match(trigger, /^on:\n  push:\n    tags:\n      - 'v\*'\n+$/);
+    for (const forbidden of [
+      "workflow_dispatch:",
+      "workflow_run:",
+      "pull_request:",
+      "pull_request_target:",
+    ]) {
+      assert.equal(releaseWorkflow.includes(forbidden), false, forbidden);
+    }
+  });
+
+  it("runs preflight before every release side effect", () => {
+    const preflight = jobBlock(releaseWorkflow, "preflight");
+
+    assert.deepEqual(permissionLines(preflight), ["contents: read"]);
+    assertInOrder(preflight, [
+      "actions/checkout@",
+      "fetch-depth: 0",
+      "actions/setup-node@",
+      "node-version: '22.14.0'",
+      "node scripts/release-preflight.js --tag \"$TAG\"",
+      "git rev-parse --verify 'HEAD^{commit}'",
+      "git rev-parse --verify \"refs/tags/${TAG}^{commit}\"",
+      'if [[ "$TAG" == *-beta.* ]]',
+      'git fetch origin "$REHEARSAL_BRANCH"',
+      "git rev-parse --verify 'FETCH_HEAD^{commit}'",
+      "git fetch origin main",
+      'git merge-base --is-ancestor "$HEAD_SHA" "$MAIN_SHA"',
+    ]);
+    assert.equal(preflight.includes("gh release"), false);
+    assert.equal(preflight.includes("npm publish"), false);
+  });
+
+  it("builds a verified staging asset before approval", () => {
+    const build = jobBlock(releaseWorkflow, "build-stage-assets");
+
+    assert.match(build, /needs: preflight/);
+    assert.deepEqual(permissionLines(build), ["contents: read"]);
+    assert.doesNotMatch(build, /^    environment:/m);
+    assert.match(build, /actions\/setup-go@[0-9a-f]{40}/);
+    assert.match(build, /actions\/setup-python@[0-9a-f]{40}/);
+    assert.match(
+      build,
+      /actions\/setup-node@249970729cb0ef3589644e2896645e5dc5ba9c38 # v6/,
+    );
+    assert.match(build, /node-version: '22.14.0'/);
+    assert.match(build, /registry-url: 'https:\/\/registry\.npmjs\.org'/);
+    assert.match(build, /package-manager-cache: false/);
+    assert.match(build, /npm install --global npm@11\.16\.0/);
+    assert.match(build, /goreleaser\/goreleaser-action@[0-9a-f]{40}/);
+    assert.match(build, /args: release --clean --skip=publish/);
+    assertInOrder(build, [
+      "actions/setup-go@",
+      "actions/setup-python@",
+      "actions/setup-node@",
+      "npm install --global npm@11.16.0",
+      "goreleaser/goreleaser-action@",
+      "sha256sum --check checksums.txt",
+      "cp dist/checksums.txt checksums.txt",
+      "npm pack --ignore-scripts --json",
+      "tar -tzf \"$PACK_FILE\" | grep -qx 'package/checksums.txt'",
+      "actions/upload-artifact@",
+    ]);
+    assert.equal(build.includes("npm stage publish"), false);
+  });
+
+  it("limits the protected job to verifying and staging the prepared npm asset", () => {
+    const publish = jobBlock(releaseWorkflow, "stage-publish");
+
+    assert.match(publish, /needs: build-stage-assets/);
+    assert.deepEqual(permissionLines(publish), ["id-token: write"]);
+    assert.match(publish, /^    environment: npm-production$/m);
+    assert.doesNotMatch(publish, /actions\/checkout@/);
+    assert.doesNotMatch(publish, /goreleaser\/goreleaser-action@/);
+    assert.doesNotMatch(publish, /GITHUB_TOKEN:/);
+    assertInOrder(publish, [
+      "actions/setup-node@",
+      "npm install --global npm@11.16.0",
+      "actions/download-artifact@",
+      "sha256sum --check checksums.txt",
+      "tar -tzf \"$PACK_FILE\" | grep -qx 'package/checksums.txt'",
+      'npm stage publish "${{ steps.asset.outputs.filename }}" --access public --tag beta',
+    ]);
+    for (const forbidden of [
+      "gh release download",
+      "npm view",
+      "LOCAL_INTEGRITY",
+      "REMOTE_INTEGRITY",
+      "secrets.NPM_TOKEN",
+      "NODE_AUTH_TOKEN",
+      "GITHUB_TOKEN:",
+      "gh release create",
+    ]) {
+      assert.equal(releaseWorkflow.includes(forbidden), false, forbidden);
+    }
+    assert.equal(/(^|\s)npm publish(?:\s|$)/m.test(publish), false);
+  });
+});
+
+describe("preview isolation", () => {
+  it("keeps preview publishing away from production credentials and registry", () => {
+    assert.equal(previewWorkflow.includes("id-token: write"), false);
+    assert.equal(previewWorkflow.includes("npm publish"), false);
+    assert.equal(previewWorkflow.includes("registry.npmjs.org"), false);
+    assert.equal(previewWorkflow.includes("secrets.NPM_TOKEN"), false);
+    assert.equal(previewWorkflow.includes("NODE_AUTH_TOKEN"), false);
+  });
+});

scripts/release-workflow.test.sh

@@ -1,144 +0,0 @@
-#!/usr/bin/env bash
-# Copyright (c) 2026 Lark Technologies Pte. Ltd.
-# SPDX-License-Identifier: MIT
-
-set -euo pipefail
-
-# This verifies the release workflow's declarative contract. The shell commands
-# inside individual steps are exercised by the beta release rehearsal instead.
-ruby -ryaml <<'RUBY'
-workflow = YAML.load_file(".github/workflows/release.yml")
-goreleaser = YAML.load_file(".goreleaser.yml")
-
-def fail(message)
-  abort("release workflow contract: #{message}")
-end
-
-def expect_equal(actual, expected, description)
-  return if actual == expected
-  fail("#{description}; expected #{expected.inspect}, got #{actual.inspect}")
-end
-
-def scalar_values(value)
-  case value
-  when Hash then value.values.flat_map { |item| scalar_values(item) }
-  when Array then value.flat_map { |item| scalar_values(item) }
-  else [value]
-  end
-end
-
-def action_references(value)
-  case value
-  when Hash
-    value.flat_map { |key, item| key == "uses" ? [item] : action_references(item) }
-  when Array
-    value.flat_map { |item| action_references(item) }
-  else
-    []
-  end
-end
-
-jobs = workflow.fetch("jobs")
-expected_jobs = %w[preflight build-sign-notarize create-draft-release verify-macos publish-github publish-npm retry-guidance]
-expect_equal(jobs.keys.sort, expected_jobs.sort, "release jobs")
-
-expect_equal(workflow.fetch("concurrency"), {
-  "group" => "release-${{ github.ref_name }}",
-  "cancel-in-progress" => false,
-}, "release concurrency")
-
-expected_needs = {
-  "preflight" => nil,
-  "build-sign-notarize" => "preflight",
-  "create-draft-release" => %w[preflight build-sign-notarize],
-  "verify-macos" => %w[preflight create-draft-release],
-  "publish-github" => %w[preflight create-draft-release verify-macos],
-  "publish-npm" => %w[preflight build-sign-notarize publish-github],
-  "retry-guidance" => %w[preflight build-sign-notarize create-draft-release verify-macos publish-github publish-npm],
-}
-expected_needs.each do |job_name, needs|
-  expect_equal(jobs.fetch(job_name)["needs"], needs, "#{job_name} dependencies")
-end
-
-expected_permissions = {
-  "preflight" => { "contents" => "read" },
-  "build-sign-notarize" => { "contents" => "read" },
-  "create-draft-release" => { "contents" => "write" },
-  "verify-macos" => { "contents" => "write" },
-  "publish-github" => { "contents" => "write" },
-  "publish-npm" => { "contents" => "read", "id-token" => "write" },
-  "retry-guidance" => { "contents" => "read" },
-}
-expected_permissions.each do |job_name, permissions|
-  expect_equal(jobs.fetch(job_name)["permissions"], permissions, "#{job_name} permissions")
-end
-expect_equal(jobs.fetch("publish-npm").fetch("environment"), "npm-production", "npm publish environment")
-
-retry_guidance = jobs.fetch("retry-guidance")
-retry_condition = "${{ always() && (needs.preflight.result == 'failure' || needs.build-sign-notarize.result == 'failure' || needs.create-draft-release.result == 'failure' || needs.verify-macos.result == 'failure' || needs.publish-github.result == 'failure' || needs.publish-npm.result == 'failure') }}"
-expect_equal(retry_guidance.fetch("if"), retry_condition, "retry guidance failure condition")
-expect_equal(retry_guidance.fetch("runs-on"), "ubuntu-22.04", "retry guidance runner")
-
-retry_steps = retry_guidance.fetch("steps")
-expect_equal(retry_steps.length, 1, "number of retry guidance steps")
-retry_step = retry_steps.first
-expect_equal(retry_step.fetch("name"), "Write retry guidance", "retry guidance step name")
-fail("retry guidance must write to the GitHub step summary") unless retry_step.fetch("run").include?("GITHUB_STEP_SUMMARY")
-
-signing_references = %w[
-  secrets.MACOS_SIGN_P12
-  secrets.MACOS_SIGN_PASSWORD
-  secrets.MACOS_NOTARY_KEY
-  vars.MACOS_NOTARY_KEY_ID
-  vars.MACOS_NOTARY_ISSUER_ID
-]
-team_reference = "vars.MACOS_TEAM_ID"
-jobs.each do |job_name, job|
-  references = scalar_values(job).grep(String).flat_map do |value|
-    (signing_references + [team_reference]).select { |reference| value.include?(reference) }
-  end.uniq.sort
-  expected_references = case job_name
-                        when "build-sign-notarize" then signing_references + [team_reference]
-                        when "verify-macos" then [team_reference]
-                        else []
-                        end
-  expect_equal(
-    references,
-    expected_references.sort,
-    "#{job_name} Apple credential scope",
-  )
-end
-
-macos = jobs.fetch("verify-macos")
-expect_equal(macos.fetch("strategy").fetch("matrix").fetch("include"), [
-  { "runner" => "macos-15-intel", "arch" => "amd64" },
-  { "runner" => "macos-15", "arch" => "arm64" },
-], "macOS verification matrix")
-expect_equal(macos.fetch("runs-on"), "${{ matrix.runner }}", "macOS matrix runner")
-
-npm_steps = jobs.fetch("publish-npm").fetch("steps")
-pinned_npm = npm_steps.find { |step| step["name"] == "Install pinned npm" }
-fail("publish-npm must install npm 11.16.0 for trusted publishing") unless pinned_npm&.fetch("run", nil) == "npm install --global npm@11.16.0"
-
-action_references(workflow).each do |reference|
-  fail("action is not pinned to a full commit SHA: #{reference}") unless reference.match?(%r{\A[^@]+@[0-9a-f]{40}\z})
-end
-
-notarize = goreleaser.fetch("notarize").fetch("macos")
-expect_equal(notarize.length, 1, "number of macOS notarization configurations")
-macos_notarize = notarize.first
-expect_equal(macos_notarize.fetch("ids"), ["lark-cli"], "notarized build IDs")
-expect_equal(macos_notarize.fetch("sign"), {
-  "certificate" => "{{ .Env.MACOS_SIGN_P12 }}",
-  "password" => "{{ .Env.MACOS_SIGN_PASSWORD }}",
-}, "macOS signing inputs")
-expect_equal(macos_notarize.fetch("notarize"), {
-  "issuer_id" => "{{ .Env.MACOS_NOTARY_ISSUER_ID }}",
-  "key_id" => "{{ .Env.MACOS_NOTARY_KEY_ID }}",
-  "key" => "{{ .Env.MACOS_NOTARY_KEY_PATH }}",
-  "wait" => true,
-  "timeout" => "20m",
-}, "macOS notarization inputs")
-
-puts "release workflow contract passed"
-RUBY

scripts/semantic-review-workflow.test.sh

@@ -176,15 +176,7 @@ if ! grep -Fq "if: always() && github.event.workflow_run.conclusion == 'success'
   exit 1
 fi
 
-if grep -Fq 'run.name !== "CI"' "$workflow"; then
-  echo "semantic-review must not use the dynamic workflow run name as workflow identity" >&2
-  exit 1
-fi
-
-require_in_step "$summary_verify_step" 'github.rest.actions.getWorkflow' "PR quality summary must resolve static workflow metadata"
-require_in_step "$summary_verify_step" 'workflow.name !== "CI"' "PR quality summary must verify the static workflow name"
-require_in_step "$summary_verify_step" 'workflow.path !== ".github/workflows/ci.yml"' "PR quality summary must verify the static workflow path"
-require_in_step "$summary_verify_step" 'run.path && run.path !== workflow.path' "PR quality summary must reject workflow path metadata mismatches"
+require_in_step "$summary_verify_step" 'workflowPath !== ".github/workflows/ci.yml"' "PR quality summary must verify the triggering workflow path"
 require_in_step "$summary_verify_step" 'run.event !== "pull_request"' "PR quality summary must only handle pull_request workflow_run events"
 require_in_step "$summary_verify_step" 'run.repository.id !== context.payload.repository.id' "PR quality summary must verify workflow_run repository id"
 require_in_step "$summary_verify_step" 'const targetHeadSha = run.head_sha' "PR quality summary must use the CI run head SHA as the verified PR head"
@@ -209,10 +201,7 @@ require_in_step "$summary_publish_step" 'CI_QUALITY_SUMMARY_BASE_SHA' "PR qualit
 require_in_step "$summary_publish_step" 'CI_QUALITY_SUMMARY_RUN_ID' "PR quality summary publisher must receive verified workflow run id"
 require_in_step "$summary_publish_step" 'require("./scripts/ci-quality-summary-publish.js")' "PR quality summary publisher must use the shared CI publisher script"
 
-require_in_step "$verify_step" 'github.rest.actions.getWorkflow' "semantic-review must resolve static workflow metadata"
-require_in_step "$verify_step" 'workflow.name !== "CI"' "semantic-review must verify the static workflow name"
-require_in_step "$verify_step" 'workflow.path !== ".github/workflows/ci.yml"' "semantic-review must verify the static workflow path"
-require_in_step "$verify_step" 'run.path && run.path !== workflow.path' "semantic-review must reject workflow path metadata mismatches"
+require_in_step "$verify_step" 'workflowPath !== ".github/workflows/ci.yml"' "semantic-review must verify the triggering workflow path"
 require_in_step "$verify_step" 'run.repository.id !== context.payload.repository.id' "semantic-review must verify workflow_run repository id"
 require_in_step "$verify_step" 'run.event !== "pull_request"' "semantic-review must only handle pull_request workflow_run events"
 require_in_step "$verify_step" 'run.conclusion !== "success"' "semantic-review must only consume successful CI runs"

scripts/tag-release.sh

@@ -7,29 +7,68 @@ cd "${REPO_ROOT}"
 
 VERSION=$(node -p "require('./package.json').version")
 TAG="v${VERSION}"
+REHEARSAL_BRANCH="test/npm-staged-publish-rehearsal"
+PUSH_TAG=false
+
+if [ "$#" -eq 1 ] && [ "$1" = "--push" ]; then
+  PUSH_TAG=true
+elif [ "$#" -ne 0 ]; then
+  echo "Usage: $0 [--push]" >&2
+  exit 1
+fi
 
 node "${SCRIPT_DIR}/release-preflight.js" --tag "${TAG}"
 
+if [[ ! "${VERSION}" =~ ^[0-9]+\.[0-9]+\.[0-9]+-beta\.[0-9]+$ ]]; then
+  echo "Error: rehearsal releases require an X.Y.Z-beta.N version." >&2
+  exit 1
+fi
+
 echo "Version: ${VERSION}"
 echo "Tag: ${TAG}"
 
 CURRENT_BRANCH=$(git branch --show-current)
-if [ "${CURRENT_BRANCH}" != "main" ]; then
-  echo "Error: releases must be tagged from main; current branch is '${CURRENT_BRANCH}'." >&2
+if [ "${CURRENT_BRANCH}" != "${REHEARSAL_BRANCH}" ]; then
+  echo "Error: rehearsal tags must be created from ${REHEARSAL_BRANCH}; current branch is '${CURRENT_BRANCH}'." >&2
   exit 1
 fi
 
-if ! git diff --quiet HEAD -- package.json package-lock.json; then
-  echo "Error: package.json or package-lock.json has uncommitted changes. Please commit them before tagging." >&2
+if [ -n "$(git status --porcelain)" ]; then
+  echo "Error: the working tree must be clean before tagging." >&2
   exit 1
 fi
 
-git fetch origin main
+git fetch origin "${REHEARSAL_BRANCH}"
 
 HEAD_SHA=$(git rev-parse HEAD)
-FETCHED_MAIN_SHA=$(git rev-parse "FETCH_HEAD^{commit}")
-if [ "${HEAD_SHA}" != "${FETCHED_MAIN_SHA}" ]; then
-  echo "Error: HEAD must exactly match origin/main before tagging." >&2
+FETCHED_REHEARSAL_SHA=$(git rev-parse "FETCH_HEAD^{commit}")
+if [ "${HEAD_SHA}" != "${FETCHED_REHEARSAL_SHA}" ]; then
+  echo "Error: HEAD must exactly match origin/${REHEARSAL_BRANCH} before tagging." >&2
+  exit 1
+fi
+
+WORKFLOW=$(git show "${HEAD_SHA}:.github/workflows/release.yml")
+if ! grep -Fq 'args: release --clean --skip=publish' <<<"${WORKFLOW}" ||
+   ! grep -Eq 'npm stage publish .*--tag beta' <<<"${WORKFLOW}" ||
+   grep -Eq '(^|[[:space:]])npm publish([[:space:]]|$)' <<<"${WORKFLOW}" ||
+   grep -Eq 'gh[[:space:]]+release([[:space:]]|$)' <<<"${WORKFLOW}" ||
+   grep -Eq 'contents:[[:space:]]*write' <<<"${WORKFLOW}" ||
+   grep -Fq 'GITHUB_TOKEN:' <<<"${WORKFLOW}"; then
+  echo "Error: the tagged workflow must be stage-only, read-only for repository contents, and must not create a GitHub Release or publish npm live." >&2
+  exit 1
+fi
+
+set +e
+NPM_VIEW_OUTPUT=$(npm view "@larksuite/cli@${VERSION}" version --registry=https://registry.npmjs.org/ 2>&1)
+NPM_VIEW_STATUS=$?
+set -e
+if [ "${NPM_VIEW_STATUS}" -eq 0 ]; then
+  echo "Error: @larksuite/cli@${VERSION} already exists on npm." >&2
+  exit 1
+fi
+if ! grep -Eq 'E404|404 Not Found' <<<"${NPM_VIEW_OUTPUT}"; then
+  echo "Error: npm version lookup failed; refusing to assume the version is unused." >&2
+  echo "${NPM_VIEW_OUTPUT}" >&2
   exit 1
 fi
 
@@ -44,7 +83,22 @@ if [ -n "${REMOTE_TAG}" ]; then
   exit 1
 fi
 
+if [ "${PUSH_TAG}" != true ]; then
+  echo "Checks passed. No tag was created or pushed."
+  echo "Run '$0 --push' only after reviewing the commit and workflow."
+  exit 0
+fi
+
+echo "Branch: ${CURRENT_BRANCH}"
+echo "Commit: ${HEAD_SHA}"
+printf 'Type %s to create and push this tag: ' "${TAG}"
+read -r CONFIRM_TAG
+if [ "${CONFIRM_TAG}" != "${TAG}" ]; then
+  echo "Error: confirmation did not exactly match ${TAG}." >&2
+  exit 1
+fi
+
 git tag "${TAG}" "${HEAD_SHA}"
-git push origin "refs/tags/${TAG}"
+git push origin "refs/tags/${TAG}:refs/tags/${TAG}"
 
 echo "Successfully pushed tag ${TAG}"

shortcuts/apps/apps_automation_skill_contract_test.go

@@ -1,469 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"testing"
-)
-
-const automationSkillDoc = "../../skills/lark-apps/references/lark-apps-automation.md"
-const localDevSkillDoc = "../../skills/lark-apps/references/lark-apps-local-dev.md"
-const larkAppsSkillDoc = "../../skills/lark-apps/SKILL.md"
-const releaseGetSkillDoc = "../../skills/lark-apps/references/lark-apps-release-get.md"
-
-func readAutomationSkillDoc(t *testing.T) string {
-	return readAppsSkillDoc(t, automationSkillDoc)
-}
-
-func readLocalDevSkillDoc(t *testing.T) string {
-	return readAppsSkillDoc(t, localDevSkillDoc)
-}
-
-func readReleaseGetSkillDoc(t *testing.T) string {
-	return readAppsSkillDoc(t, releaseGetSkillDoc)
-}
-
-func readAppsSkillDoc(t *testing.T, path string) string {
-	t.Helper()
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatalf("read skill doc %s: %v", path, err)
-	}
-	return string(raw)
-}
-
-func skillSection(t *testing.T, doc, heading string) string {
-	t.Helper()
-	start := strings.Index(doc, heading)
-	if start < 0 {
-		t.Fatalf("missing skill section %q", heading)
-	}
-	rest := doc[start+len(heading):]
-	if next := strings.Index(rest, "\n## "); next >= 0 {
-		return rest[:next]
-	}
-	return rest
-}
-
-func skillSubsection(t *testing.T, doc, heading string) string {
-	t.Helper()
-	start := strings.Index(doc, heading)
-	if start < 0 {
-		t.Fatalf("missing skill subsection %q", heading)
-	}
-	rest := doc[start+len(heading):]
-	end := len(rest)
-	for _, marker := range []string{"\n### ", "\n## "} {
-		if next := strings.Index(rest, marker); next >= 0 && next < end {
-			end = next
-		}
-	}
-	return rest[:end]
-}
-
-func requireInOrder(t *testing.T, text string, tokens ...string) {
-	t.Helper()
-	offset := 0
-	for _, token := range tokens {
-		idx := strings.Index(text[offset:], token)
-		if idx < 0 {
-			t.Fatalf("missing %q after %q", token, text[:offset])
-		}
-		offset += idx + len(token)
-	}
-}
-
-func requireFirstOccurrencesInOrder(t *testing.T, text string, tokens ...string) {
-	t.Helper()
-	previous := -1
-	for _, token := range tokens {
-		idx := strings.Index(text, token)
-		if idx < 0 {
-			t.Fatalf("missing %q", token)
-		}
-		if idx <= previous {
-			t.Fatalf("first %q at %d must follow the previous contract token at %d", token, idx, previous)
-		}
-		previous = idx
-	}
-}
-
-func TestAutomationSkillContract_ChangedHandlerStartWaitsForThisRelease(t *testing.T) {
-	section := skillSubsection(t, readAutomationSkillDoc(t), "### 实现或更新 handler 后发布并启动/测试")
-
-	requireInOrder(t, section,
-		"仅当本轮确实需要新增或修改 cron、webhook、record-change 的 `INSERT`、`UPDATE`、`DELETE` handler",
-		"+automation-get",
-		"记录发布前状态",
-		"--name",
-		"项目 guide",
-		"按项目 guide 完成同名业务 handler 并本地验证。",
-		"在 Git 已确认/预授权时 commit，然后执行",
-		"git push origin sprint/default",
-		"临时停用授权",
-		"+automation-disable",
-		"确认 disabled",
-		"+release-create --branch sprint/default",
-		"data.release_id",
-		"+release-get",
-		"data.status=finished",
-		"仅启动",
-		"+automation-enable",
-		"+automation-get",
-		"不制造 runtime probe",
-		"测试",
-		"运行时验证的操作级授权",
-		"完成全部 preflight",
-		"才执行 `+automation-enable`",
-		"真实 runtime",
-		"仅要求测试",
-		"恢复到发布前状态",
-	)
-	requireFirstOccurrencesInOrder(t, section,
-		"+automation-get",
-		"git push origin sprint/default",
-		"临时停用授权",
-		"+automation-disable",
-		"+release-create --branch sprint/default",
-		"data.status=finished",
-		"仅启动",
-	)
-	for _, boundary := range []string{
-		"仅当本轮确实需要新增或修改 cron、webhook、record-change 的 `INSERT`、`UPDATE`、`DELETE` handler，且用户要求把这次代码发布后启动或测试时，才使用此路径。",
-		"按项目 guide 完成同名业务 handler 并本地验证。",
-		"在 Git 已确认/预授权时 commit，然后执行 `git push origin sprint/default`。",
-		"若该命令本身返回错误或未返回 `data.release_id`：视为确认未创建本轮 release（新代码未上线），原本 enabled 的 trigger 恢复 enabled 并回读、原本 disabled 的保持 disabled 后停止；若因超时等导致结果未知，保持 disabled，先用 `+release-list --status finished --page-size 1` 核对是否已产生新 release 再决定。",
-		"只有 `data.status=finished` 才能继续；`publishing` 时每 20 秒继续轮询，整体最多约 5 分钟。",
-		"确认 `failed` 时报告发布失败，原本 enabled 的 trigger 仅在确认新代码未上线后恢复 enabled，原本 disabled 的保持 disabled。",
-		"发布状态仍不确定时不得进入 enable、probe 或状态恢复分支。",
-		"**仅启动**：取得持续启动授权后执行 `+automation-enable`，并用 `+automation-get` 确认 enabled；到此结束，不制造 runtime probe。",
-		"**测试（含“启动并测试”）**：先按下节“运行时验证的操作级授权”完成全部 preflight",
-		"若用户仅要求测试而不是持续启动，只在本轮 release 已 `finished` 且 probe 成功后恢复到发布前状态",
-		"无论用户是仅测试还是启动并测试，probe 失败、结果不确定或 enable 后提前结束时，一律 `+automation-disable` 并回读 disabled",
-		"不得把“发布前 enabled”当作失败后的恢复依据",
-		"没有通用的 `automation-debug` 或 trigger 日志 shortcut。",
-	} {
-		if !strings.Contains(section, boundary) {
-			t.Errorf("complete-start section must explain %q boundary", boundary)
-		}
-	}
-}
-
-func TestAutomationSkillContract_BindsTheExactNameAsUser(t *testing.T) {
-	doc := readAutomationSkillDoc(t)
-	for _, boundary := range []string{
-		"全部操作需 `--as user`（AuthType: user）。",
-		"当用户希望触发器实际执行业务代码时，先确认当前工作区是已初始化的应用项目，并读取其中与触发器任务匹配的 guide。",
-		"`--name` 是应用内唯一的 trigger 定位键；代码侧绑定名称必须与它逐字相同。不得用 trigger ID 或方法名代替它。具体 handler 语法和接入方式以项目 guide 为准。",
-	} {
-		if !strings.Contains(doc, boundary) {
-			t.Errorf("automation skill must preserve %q", boundary)
-		}
-	}
-}
-
-func TestAutomationSkillContract_RoutesAndDiagnosesUnfiredTriggers(t *testing.T) {
-	doc := readAutomationSkillDoc(t)
-	routeSection := skillSection(t, doc, "## 何时用本 skill（路由锚点）")
-	errorSection := skillSection(t, doc, "## 常见错误与决策场景")
-
-	if !strings.Contains(routeSection, "「触发器没反应 / enable 了不触发 / 为什么没执行 / 验证一下触发器」→ 先按「未触发时的诊断顺序」诊断；对 UPSERT 和 feishu-approval 仅验证配置边界，不承诺 handler 或 live 验证。") {
-		t.Error("routing anchors must direct unfired triggers to the bounded diagnostic flow")
-	}
-	if !strings.Contains(errorSection, "已证实的 cron、webhook、record-change（INSERT/UPDATE/DELETE）按「未触发时的诊断顺序」排查；UPSERT 和 feishu-approval 仅核对配置边界，不承诺 handler 或 live 验证。") {
-		t.Error("error table must preserve the bounded unfired-trigger diagnostic flow")
-	}
-}
-
-func TestAutomationSkillContract_ConfigurationStopsDisabled(t *testing.T) {
-	section := skillSubsection(t, readAutomationSkillDoc(t), "### 仅创建/配置触发器")
-
-	for _, boundary := range []string{
-		"用 `+automation-create` 创建，并省略 `--status` 或显式传 `disabled`，然后报告 name 和 disabled 状态。",
-		"不要传 `--status enabled`，也不要写 handler、commit/push、release 或 enable；更不能把创建 API 成功称为“可运行”。",
-		"默认 disabled 是这个意图的终点，不是稍后自动 enable 的待办。",
-	} {
-		if !strings.Contains(section, boundary) {
-			t.Errorf("configuration-only section must preserve %q", boundary)
-		}
-	}
-}
-
-func TestAutomationSkillContract_EnableExistingTriggerDoesNotPublish(t *testing.T) {
-	doc := readAutomationSkillDoc(t)
-	section := skillSubsection(t, doc, "### 仅启用已有 disabled trigger")
-	routeSection := skillSection(t, doc, "## 何时用本 skill（路由锚点）")
-
-	requireInOrder(t, section,
-		"用户只要求启用已存在且 disabled 的 trigger",
-		"+automation-get",
-		"+release-list --status finished --page-size 1",
-		"已完成线上 release",
-		"当前线上应用",
-		"不能证明该 trigger name 已绑定 handler",
-		"+automation-enable",
-		"+automation-get",
-		"不得修改 handler、commit/push 或 release",
-		"对 UPSERT 或 feishu-approval 只改变配置状态",
-	)
-	if !strings.Contains(section, "未发布时不得自动创建 release，也不得声称 trigger 已开始实际运行") {
-		t.Error("enable-only flow must distinguish configuration enablement from a published runtime")
-	}
-	if !strings.Contains(section, "即使存在 finished release，也只能把 enable 报告为配置激活") {
-		t.Error("enable-only flow must not infer handler provenance from app release history")
-	}
-	if strings.Contains(section, "apps +get") || strings.Contains(section, "`is_published`") {
-		t.Error("enable-only flow must use finished release history instead of an optional app detail field")
-	}
-	for _, forbidden := range []string{"git push", "+release-create"} {
-		if strings.Contains(section, forbidden) {
-			t.Errorf("enable-only flow must not contain %q", forbidden)
-		}
-	}
-	if !strings.Contains(routeSection, "「启用 / 启动已有 trigger」→ 先核对现有状态；只启用时不要修改源码或发布应用。") {
-		t.Error("routing anchors must keep existing-trigger enablement separate from code release")
-	}
-}
-
-func TestAutomationSkillContract_TestExistingTriggerDoesNotPublish(t *testing.T) {
-	section := skillSubsection(t, readAutomationSkillDoc(t), "### 测试已有线上 trigger（不改代码）")
-
-	requireInOrder(t, section,
-		"用户要求测试已经发布的 trigger",
-		"+automation-get",
-		"+release-list --status finished --page-size 1",
-		"当前线上代码",
-		"不得为测试自动修改源码、commit/push 或 release",
-		"在任何临时 enable 之前完成",
-		"测试请求已明确包含临时 enable，或另行取得 enable 授权",
-		"运行时验证的操作级授权",
-		"无论 probe 成功、失败、结果不确定，还是临时 enable 后提前结束或中断，最终都必须 `+automation-disable` 并回读 disabled",
-	)
-	for _, forbidden := range []string{"git push", "+release-create"} {
-		if strings.Contains(section, forbidden) {
-			t.Errorf("existing-trigger test flow must not contain %q", forbidden)
-		}
-	}
-}
-
-func TestAutomationSkillContract_HandlerOnlyStopsBeforeRelease(t *testing.T) {
-	section := skillSubsection(t, readAutomationSkillDoc(t), "### 仅完成 handler（不发布/不启用）")
-
-	for _, boundary := range []string{
-		"创建或定位已明确 name 的 disabled trigger，读取项目 guide，按其要求实现同名业务 handler，完成本地验证。",
-		"只在既有 Git 确认或预授权下 commit/push；停止在 `+release-create` 和 `+automation-enable` 之前。",
-		"用户没有明确“发布好”时，先问，不能默认把完整应用上线。",
-	} {
-		if !strings.Contains(section, boundary) {
-			t.Errorf("handler-only section must preserve %q", boundary)
-		}
-	}
-}
-
-func TestAutomationSkillContract_HandlerOnlyExcludesUnverifiedRuntimeTypes(t *testing.T) {
-	section := skillSubsection(t, readAutomationSkillDoc(t), "### 仅完成 handler（不发布/不启用）")
-
-	if !strings.Contains(section, "仅对 cron、webhook、record-change 的 `INSERT`、`UPDATE`、`DELETE` 使用此路径。") {
-		t.Error("handler-only flow must exclude UPSERT and feishu-approval without a verified runtime contract")
-	}
-}
-
-func TestAutomationSkillContract_PublishedHandlerStaysDisabled(t *testing.T) {
-	section := skillSubsection(t, readAutomationSkillDoc(t), "### 把 handler 发布好，但先不要启动")
-
-	for _, boundary := range []string{
-		"仅对 cron、webhook、record-change 的 `INSERT`、`UPDATE`、`DELETE` 使用此路径。",
-		"先用 `+automation-get` 定位；不存在时用 `+automation-create` 创建同名 disabled trigger，再次回读确认。",
-		"已存在时记录它是否 enabled。",
-		"若 trigger 已 enabled，先说明发布前必须临时停用以及可能造成的运行中断，并取得这次临时停用授权；未获授权时停止在发布前。",
-		"取得授权后，在发布前执行 `+automation-disable`，并再次用 `+automation-get` 确认 disabled。",
-		"按项目 guide 完成同名业务 handler 并本地验证后，commit、`git push origin sprint/default`。",
-		"随后发布完整应用：",
-		"若 `+release-create` 本身返回错误或未返回 `data.release_id`：视为确认未创建本轮 release（新代码未上线），原本 enabled 的 trigger 恢复 enabled 并回读、原本 disabled 的保持 disabled，然后停止；若因超时等导致创建结果未知，保持 disabled，先用 `+release-list --status finished --page-size 1` 核对是否已产生新 release 再决定。",
-		"取得 `data.release_id` 后，对**这一轮** ID 调用 `+release-get`：`publishing` 时每 20 秒继续轮询，整体最多约 5 分钟；超时且状态仍不确定时报告 `release_id` 和当前 status，并保持 disabled；只有 `data.status=finished` 才算完成。",
-		"确认 `failed` 且新代码未上线时，原本 enabled 的 trigger 恢复 enabled 并回读，原本 disabled 的保持 disabled。",
-		"release 是整个应用上线，可能影响既有线上功能；未获得启动或测试授权时，finished 后始终保持 disabled，不执行 `+automation-enable`。",
-	} {
-		if !strings.Contains(section, boundary) {
-			t.Errorf("publish-without-start section must preserve %q", boundary)
-		}
-	}
-	requireFirstOccurrencesInOrder(t, section,
-		"+automation-get",
-		"git push origin sprint/default",
-		"临时停用授权",
-		"+automation-disable",
-		"+release-create",
-	)
-}
-
-func TestAutomationSkillContract_UPSERTAndApprovalStayConfigurationOnly(t *testing.T) {
-	section := skillSubsection(t, readAutomationSkillDoc(t), "### UPSERT 与飞书审批边界")
-
-	for _, boundary := range []string{
-		"record-change 的 UPSERT 可创建 disabled 配置，但当前没有已证实的运行时代码契约；不得静默按 UPDATE 处理，也不得承诺 handler 或 live 验证。",
-		"feishu-approval 可创建 disabled 配置，并读取或更新 `event_type`、对应 status 和可选 `approval_code`。",
-		"当前没有已证实的运行时 handler 契约或实际投递验证；不要把 enable 或审批 API 成功称为业务代码已执行。",
-	} {
-		if !strings.Contains(section, boundary) {
-			t.Errorf("UPSERT/approval boundary section must preserve %q", boundary)
-		}
-	}
-}
-
-func TestAutomationSkillContract_RuntimeProbeRequiresOperationScope(t *testing.T) {
-	section := skillSubsection(t, readAutomationSkillDoc(t), "### 运行时验证的操作级授权")
-
-	for _, boundary := range []string{
-		"启用 trigger 的授权不等于制造 runtime 事件的授权，测试授权也不等于任意数据库写入授权。",
-		"record-change 在执行任何 DML 前，必须明确并取得覆盖以下作用域的授权",
-		"环境、表、操作、精确测试记录或筛选条件、payload、预期结果和清理方式",
-		"优先使用专用测试记录",
-		"`DELETE`",
-		"[lark-apps-db-execute.md](lark-apps-db-execute.md)",
-		"先 `SELECT count(*)`、执行 `--dry-run`",
-		"取得针对该删除目标的明确授权",
-		"+automation-list --trigger-type record-change --all",
-		"同一环境、表和操作可能命中的其他 enabled trigger",
-		"聚合业务影响",
-		"恢复 UPDATE 或清理 INSERT 也可能再次触发自动化",
-		"缺少安全、已授权且可清理的事件入口时，记录 blocked",
-	} {
-		if !strings.Contains(section, boundary) {
-			t.Errorf("runtime probe section must preserve %q", boundary)
-		}
-	}
-}
-
-func TestAutomationSkillContract_UsesResolvableSharedSkillLink(t *testing.T) {
-	doc := readAutomationSkillDoc(t)
-
-	if strings.Contains(doc, "](../lark-shared/SKILL.md)") {
-		t.Error("automation reference must not resolve lark-shared inside the lark-apps directory")
-	}
-	if !strings.Contains(doc, "](../../lark-shared/SKILL.md)") {
-		t.Error("automation reference must link to the sibling lark-shared skill")
-	}
-	sharedSkillDoc := filepath.Clean(filepath.Join(filepath.Dir(automationSkillDoc), "../../lark-shared/SKILL.md"))
-	if _, err := os.Stat(sharedSkillDoc); err != nil {
-		t.Fatalf("automation reference target %s must exist: %v", sharedSkillDoc, err)
-	}
-}
-
-func TestAppsSkillContract_AllSharedSkillLinksResolve(t *testing.T) {
-	docs := []string{larkAppsSkillDoc}
-	references, err := filepath.Glob("../../skills/lark-apps/references/*.md")
-	if err != nil {
-		t.Fatalf("glob lark-apps references: %v", err)
-	}
-	docs = append(docs, references...)
-	sharedLink := regexp.MustCompile(`\]\(([^)]+lark-shared/SKILL\.md)\)`)
-
-	for _, docPath := range docs {
-		doc := readAppsSkillDoc(t, docPath)
-		for _, match := range sharedLink.FindAllStringSubmatch(doc, -1) {
-			target := filepath.Clean(filepath.Join(filepath.Dir(docPath), match[1]))
-			if _, err := os.Stat(target); err != nil {
-				t.Errorf("%s shared-skill link %q resolves to missing target %s: %v", docPath, match[1], target, err)
-			}
-		}
-	}
-}
-
-func TestLocalDevSkillContract_UsesProjectGuideWithoutSyncInternals(t *testing.T) {
-	section := skillSection(t, readLocalDevSkillDoc(t), "## Trigger guide 的项目边界")
-
-	for _, boundary := range []string{
-		"先查看工作区 `.agents/skills/`，读取与自动化任务匹配的 `trigger-guide`。",
-		"文件缺失或不能覆盖当前任务时，报告项目缺少可用的领域 guide；不要在本 lark-cli reference 中猜测安装命令、版本或包内目录。",
-	} {
-		if !strings.Contains(section, boundary) {
-			t.Errorf("trigger-guide boundary section must explain %q", boundary)
-		}
-	}
-	for _, implementationShape := range []string{
-		"npx ", "skills sync", "data.", "skills_", "_CACHE_DIR", "nestjs-",
-		"@lark-apaas/miaoda-cli", "@lark-apaas/coding-steering", "miaoda-coding", "skills_common/",
-	} {
-		if strings.Contains(section, implementationShape) {
-			t.Errorf("local-dev skill must not expose project-sync implementation shape %q", implementationShape)
-		}
-	}
-}
-
-func TestAppsSkillContract_DoesNotExposeSteeringImplementation(t *testing.T) {
-	for name, doc := range map[string]string{
-		"automation": readAutomationSkillDoc(t),
-		"local-dev":  readLocalDevSkillDoc(t),
-	} {
-		for _, implementationShape := range []string{
-			"npx ", "skills sync", "@lark-apaas/miaoda-cli", "@lark-apaas/coding-steering", "miaoda-coding", "skills_common/",
-		} {
-			if strings.Contains(doc, implementationShape) {
-				t.Errorf("%s skill must not expose project-sync implementation shape %q", name, implementationShape)
-			}
-		}
-	}
-}
-
-func TestLocalDevSkillContract_UsesEnvironmentAndDefersEnableToAutomationSOP(t *testing.T) {
-	doc := readLocalDevSkillDoc(t)
-	releaseSection := skillSection(t, doc, "## 改完代码后部署上线")
-	for _, legacy := range []string{"--env dev", "--env online"} {
-		if strings.Contains(doc, legacy) {
-			t.Errorf("local-dev skill must not recommend legacy %q", legacy)
-		}
-	}
-	for _, boundary := range []string{
-		"`publishing` 时每 20 秒继续轮询，整体最多约 5 分钟；超时仍未完成时停止本轮轮询、报告 `release_id` 和当前 status。",
-		"若本次改动包含自动化 handler，在执行本节通用 commit/push/release 序列前就转到 [automation SOP](lark-apps-automation.md) 的匹配路径，由该 SOP 负责完整的状态门禁、commit/push、release 和可选 enable/test；不要先按本节发布再补 trigger 状态检查。",
-		"用户只要求启用已有 trigger 时，转到 [automation SOP 的「仅启用已有 disabled trigger」路径](lark-apps-automation.md#仅启用已有-disabled-trigger)；不得因 enable 反向修改 handler、commit/push 或 release。",
-		"使用 `--environment dev|online`，不要使用旧的 `--env`。只有确认应用已开启多环境时才引导 `--environment dev`；单环境应用省略 `--environment`（服务端选 online）或显式传 `--environment online`。",
-	} {
-		if !strings.Contains(doc, boundary) {
-			t.Errorf("local-dev skill must preserve %q", boundary)
-		}
-	}
-	routeIndex := strings.Index(releaseSection, "若本次改动包含自动化 handler")
-	releaseIndex := strings.Index(releaseSection, "+release-create")
-	if routeIndex < 0 || releaseIndex < 0 || routeIndex >= releaseIndex {
-		t.Error("automation routing must appear before the generic release sequence")
-	}
-}
-
-func TestLocalDevSkillContract_DoesNotRequireOnlineURL(t *testing.T) {
-	section := skillSection(t, readLocalDevSkillDoc(t), "## 改完代码后部署上线")
-
-	if strings.Contains(section, "`finished` 成功时该命令输出已含 `online_url`") {
-		t.Error("release guidance must not claim every finished release includes online_url")
-	}
-	if !strings.Contains(section, "若返回 `online_url`，可直接使用；未返回时不要编造链接。") {
-		t.Error("release guidance must explain that online_url is optional")
-	}
-}
-
-func TestLocalDevSkillContract_TreatsErrorLogsAsOptional(t *testing.T) {
-	section := skillSection(t, readLocalDevSkillDoc(t), "## 改完代码后部署上线")
-
-	if !strings.Contains(section, "`failed` 时若返回非空 `error_logs`，据此给出失败原因；否则只报告 `release_id` 和当前 status，不要编造原因") {
-		t.Error("release guidance must not promise error_logs on every failed release")
-	}
-}
-
-func TestReleaseSkillContract_TreatsOptionalOutputAsOptional(t *testing.T) {
-	releaseGet := readReleaseGetSkillDoc(t)
-	for _, boundary := range []string{
-		"`finished` 后才可能有 `online_url`。",
-		"若输出含 `online_url`，直接读取它作为本轮发布的线上访问链接；未返回时只报告发布完成，不要编造链接。",
-		"若输出含 `error_logs`（`step`/`error_log`），据此向用户转述关键失败步骤和可行动修复；未返回时不要编造失败原因。",
-	} {
-		if !strings.Contains(releaseGet, boundary) {
-			t.Errorf("release-get skill must preserve optional-output boundary %q", boundary)
-		}
-	}
-}

shortcuts/apps/apps_errors.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/extension/fileio"
+	"github.com/larksuite/cli/internal/client"
 )
 
 func appsValidationError(format string, args ...any) *errs.ValidationError {
@@ -73,3 +74,32 @@ func appsInputPathEntryError(path string, err error) error {
 func appsFileIOError(err error, format string, args ...any) *errs.InternalError {
 	return errs.NewInternalError(errs.SubtypeFileIO, format, args...).WithCause(err)
 }
+
+// enrichHTMLPublishAPIError adapts a typed failure from the HTML publish
+// endpoint: refines endpoint-scoped business codes, prefixes the message with
+// command context, and attaches endpoint-specific recovery hints. A
+// still-untyped error is lifted at the SDK boundary instead.
+func enrichHTMLPublishAPIError(err error) error {
+	if err == nil {
+		return nil
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok {
+		return client.WrapDoAPIError(err)
+	}
+	// The HTML publish business codes (90001/90002) are scoped to this
+	// endpoint, not service-global, so their subtype classification lives
+	// here instead of the global errclass code table. Only an
+	// otherwise-unclassified API error is refined; a stronger upstream
+	// classification is never overridden.
+	if p.Category == errs.CategoryAPI && p.Subtype == errs.SubtypeUnknown && p.Code == errCodeAppNotFound {
+		p.Subtype = errs.SubtypeNotFound
+	}
+	if p.Message != "" {
+		p.Message = "html-publish failed: " + p.Message
+	}
+	if hint := buildHTMLPublishFailureHint(p.Code); hint != "" {
+		p.Hint = hint
+	}
+	return err
+}