docs: remove lark doc workflows

Change-Id: I7d36543f090ebbb42c945667ad25534273a5c305

.github/workflows/ci.yml

@@ -5,7 +5,6 @@ on:
     branches: [main]
   pull_request:
     branches: [main]
-    types: [opened, synchronize, reopened, edited]
   workflow_dispatch:
 
 permissions:
@@ -71,7 +70,6 @@ jobs:
       - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
         with:
           fetch-depth: 0
-          persist-credentials: false
       - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6
         with:
           go-version-file: go.mod
@@ -89,23 +87,6 @@ jobs:
       - name: Run errs/ lint guards (lintcheck)
         run: go run -C lint . --changed-from "$QUALITY_GATE_CHANGED_FROM" ..
 
-  script-test:
-    needs: fast-gate
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
-        with:
-          fetch-depth: 0
-          persist-credentials: false
-      - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6
-        with:
-          go-version-file: go.mod
-      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
-        with:
-          node-version: '22'
-      - name: Run script tests
-        run: make script-test
-
   deterministic-gate:
     needs: fast-gate
     runs-on: ubuntu-latest
@@ -128,28 +109,8 @@ jobs:
         env:
           QUALITY_GATE_CHANGED_FROM: ${{ github.event.pull_request.base.sha || github.event.before || 'origin/main' }}
         run: echo "QUALITY_GATE_CHANGED_FROM=$(bash scripts/resolve-changed-from.sh)" >> "$GITHUB_ENV"
-      - name: Write public content metadata
-        if: ${{ github.event_name == 'pull_request' }}
-        env:
-          PR_TITLE: ${{ github.event.pull_request.title }}
-          PR_BODY: ${{ github.event.pull_request.body }}
-          PR_BRANCH: ${{ github.head_ref }}
-        run: |
-          mkdir -p .tmp/quality-gate
-          python3 - <<'PY'
-          import json
-          import os
-
-          with open(".tmp/quality-gate/public-content-metadata.json", "w", encoding="utf-8") as f:
-              json.dump({
-                  "title": os.environ.get("PR_TITLE", ""),
-                  "body": os.environ.get("PR_BODY", ""),
-                  "branch": os.environ.get("PR_BRANCH", ""),
-              }, f)
-              f.write("\n")
-          PY
       - name: Run CLI deterministic gate
-        run: PUBLIC_CONTENT_METADATA=.tmp/quality-gate/public-content-metadata.json make quality-gate
+        run: make quality-gate
       - name: Upload quality gate facts
         if: ${{ always() && github.event_name == 'pull_request' }}
         uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
@@ -259,7 +220,7 @@ jobs:
 
   # ── Layer 3: E2E Gate ──────────────────────────────────────────────
   e2e-dry-run:
-    needs: [unit-test, lint, script-test, deterministic-gate]
+    needs: [unit-test, lint, deterministic-gate]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
@@ -280,7 +241,7 @@ jobs:
         run: go test -v -count=1 -timeout=5m ./tests/cli_e2e/... -run 'DryRun|Regression'
 
   e2e-live:
-    needs: [unit-test, lint, script-test, deterministic-gate]
+    needs: [unit-test, lint, deterministic-gate]
     if: ${{ github.event_name != 'pull_request' || !github.event.pull_request.head.repo.fork }}
     runs-on: ubuntu-latest
     permissions:
@@ -372,7 +333,7 @@ jobs:
   # ── Results Gate (single required check for branch protection) ─────
   results:
     if: ${{ always() }}
-    needs: [fast-gate, unit-test, lint, script-test, deterministic-gate, coverage, deadcode, e2e-dry-run, e2e-live, security, license-header]
+    needs: [fast-gate, unit-test, lint, deterministic-gate, coverage, deadcode, e2e-dry-run, e2e-live, security, license-header]
     runs-on: ubuntu-latest
     steps:
       - name: Evaluate results
@@ -384,7 +345,6 @@ jobs:
           echo "| L1 | fast-gate | ${{ needs.fast-gate.result }} |" >> $GITHUB_STEP_SUMMARY
           echo "| L2 | unit-test | ${{ needs.unit-test.result }} |" >> $GITHUB_STEP_SUMMARY
           echo "| L2 | lint | ${{ needs.lint.result }} |" >> $GITHUB_STEP_SUMMARY
-          echo "| L2 | script-test | ${{ needs.script-test.result }} |" >> $GITHUB_STEP_SUMMARY
           echo "| L2 | deterministic-gate | ${{ needs.deterministic-gate.result }} |" >> $GITHUB_STEP_SUMMARY
           echo "| L2 | coverage | ${{ needs.coverage.result }} |" >> $GITHUB_STEP_SUMMARY
           echo "| L2 | deadcode | ${{ needs.deadcode.result }} |" >> $GITHUB_STEP_SUMMARY
@@ -401,7 +361,6 @@ jobs:
             "${{ needs.fast-gate.result }}" \
             "${{ needs.unit-test.result }}" \
             "${{ needs.lint.result }}" \
-            "${{ needs.script-test.result }}" \
             "${{ needs.deterministic-gate.result }}" \
             "${{ needs.coverage.result }}" \
             "${{ needs.deadcode.result }}" \

.github/workflows/comment-audit.yml

@@ -1,28 +0,0 @@
-name: Comment Audit
-
-on:
-  issue_comment:
-    types: [created, edited]
-  pull_request_review:
-    types: [submitted, edited]
-  pull_request_review_comment:
-    types: [created, edited]
-
-permissions:
-  contents: read
-
-jobs:
-  public-content-comment-audit:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
-        with:
-          persist-credentials: false
-      - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6
-        with:
-          go-version-file: go.mod
-      - name: Post-publication comment audit
-        run: |
-          mkdir -p .tmp/comment-audit
-          cp "$GITHUB_EVENT_PATH" .tmp/comment-audit/event.json
-          go run ./internal/qualitygate/cmd/comment-audit --event .tmp/comment-audit/event.json --kind "$GITHUB_EVENT_NAME"

.github/workflows/semantic-review.yml

@@ -88,44 +88,31 @@ jobs:
                 commit_sha: targetHeadSha,
               });
               const candidatePRs = associatedPRs.filter((candidate) =>
+                candidate.state === "open" &&
                 candidate.base?.repo?.id === context.payload.repository.id &&
                 candidate.head?.sha === targetHeadSha
               );
-              const openCandidatePRs = candidatePRs.filter((candidate) => candidate.state === "open");
-              if (openCandidatePRs.length > 1) {
-                throw new Error(`ambiguous open PRs for workflow_run head ${targetHeadSha}: ${openCandidatePRs.length}`);
+              if (candidatePRs.length > 1) {
+                throw new Error(`ambiguous open PRs for workflow_run head ${targetHeadSha}: ${candidatePRs.length}`);
               }
-              if (openCandidatePRs.length === 1) {
-                prNumber = openCandidatePRs[0].number;
-              } else if (candidatePRs.length > 0) {
-                core.notice("PR quality summary skipped: workflow_run target PR is no longer open");
-                core.setOutput("stale", "true");
-                return;
+              if (candidatePRs.length === 1) {
+                prNumber = candidatePRs[0].number;
               }
             }
             if (!prNumber) {
               const candidatePRs = await github.paginate(github.rest.pulls.list, {
                 owner: context.repo.owner,
                 repo: context.repo.repo,
-                state: "all",
+                state: "open",
                 per_page: 100,
               }).then((prs) => prs.filter((candidate) =>
                 candidate.base?.repo?.id === context.payload.repository.id &&
                 candidate.head?.sha === targetHeadSha
               ));
-              const openCandidatePRs = candidatePRs.filter((candidate) => candidate.state === "open");
-              if (openCandidatePRs.length > 1) {
-                throw new Error(`ambiguous open PRs from pull list fallback for workflow_run head ${targetHeadSha}: ${openCandidatePRs.length}`);
-              }
-              if (openCandidatePRs.length === 1) {
-                prNumber = openCandidatePRs[0].number;
-              } else if (candidatePRs.length > 0) {
-                core.notice("PR quality summary skipped: workflow_run target PR is no longer open");
-                core.setOutput("stale", "true");
-                return;
-              } else {
+              if (candidatePRs.length !== 1) {
                 throw new Error(`expected one open PR from pull list fallback for workflow_run head ${targetHeadSha}, got ${candidatePRs.length}`);
               }
+              prNumber = candidatePRs[0].number;
             }
             if (!Number.isInteger(prNumber) || prNumber <= 0) throw new Error("missing pull request binding");
             const { data: pr } = await github.rest.pulls.get({
@@ -134,11 +121,6 @@ jobs:
               pull_number: prNumber,
             });
             if (pr.base.repo.id !== context.payload.repository.id) throw new Error("PR base repo mismatch");
-            if (pr.state !== "open") {
-              core.notice("PR quality summary skipped: workflow_run target PR is no longer open");
-              core.setOutput("stale", "true");
-              return;
-            }
             if (pr.head.sha !== targetHeadSha) {
               core.notice("PR quality summary skipped: workflow_run is stale for this PR head");
               core.setOutput("stale", "true");
@@ -317,44 +299,31 @@ jobs:
                 commit_sha: targetHeadSha,
               });
               const candidatePRs = associatedPRs.filter((candidate) =>
+                candidate.state === "open" &&
                 candidate.base?.repo?.id === context.payload.repository.id &&
                 candidate.head?.sha === targetHeadSha
               );
-              const openCandidatePRs = candidatePRs.filter((candidate) => candidate.state === "open");
-              if (openCandidatePRs.length > 1) {
-                throw new Error(`ambiguous open PRs for workflow_run head ${targetHeadSha}: ${openCandidatePRs.length}`);
+              if (candidatePRs.length > 1) {
+                throw new Error(`ambiguous open PRs for workflow_run head ${targetHeadSha}: ${candidatePRs.length}`);
               }
-              if (openCandidatePRs.length === 1) {
-                prNumber = openCandidatePRs[0].number;
-              } else if (candidatePRs.length > 0) {
-                core.notice("semantic review skipped: workflow_run target PR is no longer open");
-                core.setOutput("stale", "true");
-                return;
+              if (candidatePRs.length === 1) {
+                prNumber = candidatePRs[0].number;
               }
             }
             if (!prNumber) {
               const candidatePRs = await github.paginate(github.rest.pulls.list, {
                 owner: context.repo.owner,
                 repo: context.repo.repo,
-                state: "all",
+                state: "open",
                 per_page: 100,
               }).then((prs) => prs.filter((candidate) =>
                 candidate.base?.repo?.id === context.payload.repository.id &&
                 candidate.head?.sha === targetHeadSha
               ));
-              const openCandidatePRs = candidatePRs.filter((candidate) => candidate.state === "open");
-              if (openCandidatePRs.length > 1) {
-                throw new Error(`ambiguous open PRs from pull list fallback for workflow_run head ${targetHeadSha}: ${openCandidatePRs.length}`);
-              }
-              if (openCandidatePRs.length === 1) {
-                prNumber = openCandidatePRs[0].number;
-              } else if (candidatePRs.length > 0) {
-                core.notice("semantic review skipped: workflow_run target PR is no longer open");
-                core.setOutput("stale", "true");
-                return;
-              } else {
+              if (candidatePRs.length !== 1) {
                 throw new Error(`expected one open PR from pull list fallback for workflow_run head ${targetHeadSha}, got ${candidatePRs.length}`);
               }
+              prNumber = candidatePRs[0].number;
             }
             if (!Number.isInteger(prNumber) || prNumber <= 0) throw new Error("missing pull request binding");
             const { data: pr } = await github.rest.pulls.get({
@@ -363,16 +332,6 @@ jobs:
               pull_number: prNumber,
             });
             if (pr.base.repo.id !== context.payload.repository.id) throw new Error("PR base repo mismatch");
-            if (pr.state !== "open") {
-              core.notice("semantic review skipped: workflow_run target PR is no longer open");
-              core.setOutput("stale", "true");
-              return;
-            }
-            if (!pr.head.repo) {
-              core.notice("semantic review skipped: workflow_run target PR head repository is unavailable");
-              core.setOutput("stale", "true");
-              return;
-            }
             if (pr.head.sha !== targetHeadSha) {
               core.notice("semantic review skipped: workflow_run is stale for this PR head");
               core.setOutput("stale", "true");
@@ -430,10 +389,6 @@ jobs:
               repo: context.repo.repo,
               pull_number: pr,
             });
-            if (pull.state !== "open") {
-              core.notice("semantic review skipped infrastructure failure check: PR is no longer open");
-              return;
-            }
             if (pull.head.sha !== headSha) {
               core.notice("semantic review skipped infrastructure failure check: PR head changed");
               return;

.gitignore

@@ -51,4 +51,3 @@ app.log
 cover*.out
 
 lark-env.sh
-/automations/

CHANGELOG.md

@@ -2,47 +2,6 @@
 
 All notable changes to this project will be documented in this file.
 
-## [v1.0.59] - 2026-06-26
-
-### Features
-
-- **slides**: Add `+replace-pages` and `xml get` shortcuts, and expose the presentation URL (#1585)
-- **minutes**: Support speaker list and no-Lark speaker replace (#1594)
-- **calendar/vc/minutes**: Optimize and extend calendar, vc, minutes, and note shortcuts and skills (#1571)
-
-### Bug Fixes
-
-- **docs**: Hide docs `api-version` compat flag (#1580)
-
-## [v1.0.58] - 2026-06-25
-
-### Features
-
-- **sheets**: Typed table I/O and error contract, workbook import/export, and skill refresh (#1355)
-- **base**: Add Base URL and title resolve shortcuts (#1338)
-- **drive**: Add `+member-add` shortcut with wiki space member collection collaborator support (#1204)
-- **doc**: Support `create` title option (#1536)
-- **doc**: Add `im-markdown` output format for doc fetch (#1550)
-- **whiteboard**: Export whiteboard as SVG and update whiteboard via SVG (#1559)
-- **card**: Support `card.action.trigger` event with auto-fetched card content (#1528)
-- **task**: Add task event consumer (#1510)
-
-### Bug Fixes
-
-- **doc**: Prefix docs resource shortcuts (#1564)
-- **binding**: Skip unix mode audit on Windows (#1525)
-
-### Documentation
-
-- **approval**: Sync approval skill for meta API commands (#1499)
-- **doc**: Restore lark-doc style requirements (#1579)
-- **im**: Document `chat.nickname` get/update/delete (#1378)
-- **im**: Clarify audio message opus requirement (#1271)
-
-### Build
-
-- **ci**: Add public content safeguards and reduce false positives
-
 ## [v1.0.57] - 2026-06-23
 
 ### Features
@@ -1277,8 +1236,6 @@ Bundled AI agent skills for intelligent assistance:
 - Bilingual documentation (English & Chinese).
 - CI/CD pipelines: linting, testing, coverage reporting, and automated releases.
 
-[v1.0.59]: https://github.com/larksuite/cli/releases/tag/v1.0.59
-[v1.0.58]: https://github.com/larksuite/cli/releases/tag/v1.0.58
 [v1.0.57]: https://github.com/larksuite/cli/releases/tag/v1.0.57
 [v1.0.56]: https://github.com/larksuite/cli/releases/tag/v1.0.56
 [v1.0.55]: https://github.com/larksuite/cli/releases/tag/v1.0.55

Makefile

@@ -12,7 +12,6 @@ QUALITY_GATE_DIR ?= .tmp/quality-gate
 QUALITY_GATE_MANIFEST_OUT ?= $(QUALITY_GATE_DIR)/command-manifest.json
 QUALITY_GATE_COMMAND_INDEX_OUT ?= $(QUALITY_GATE_DIR)/command-index.json
 QUALITY_GATE_FACTS_OUT ?= $(QUALITY_GATE_DIR)/facts.json
-PUBLIC_CONTENT_METADATA ?= $(QUALITY_GATE_DIR)/public-content-metadata.json
 LDFLAGS  := -s -w -X $(MODULE)/internal/build.Version=$(VERSION) -X $(MODULE)/internal/build.Date=$(DATE)
 PREFIX   ?= /usr/local
 
@@ -70,8 +69,7 @@ integration-test: build
 test: vet fmt-check script-test unit-test examples-build integration-test
 
 quality-gate: build
-	mkdir -p $(QUALITY_GATE_DIR) $(dir $(QUALITY_GATE_FACTS_OUT)) $(dir $(PUBLIC_CONTENT_METADATA))
-	test -f $(PUBLIC_CONTENT_METADATA) || printf '{}\n' > $(PUBLIC_CONTENT_METADATA)
+	mkdir -p $(QUALITY_GATE_DIR) $(dir $(QUALITY_GATE_FACTS_OUT))
 	LARKSUITE_CLI_REMOTE_META=off \
 	LARKSUITE_CLI_NO_UPDATE_NOTIFIER=1 \
 	LARKSUITE_CLI_NO_SKILLS_NOTIFIER=1 \
@@ -91,7 +89,6 @@ quality-gate: build
 		--changed-from $(QUALITY_GATE_CHANGED_FROM_RESOLVED) \
 		--manifest $(QUALITY_GATE_MANIFEST_OUT) \
 		--command-index $(QUALITY_GATE_COMMAND_INDEX_OUT) \
-		--public-content-metadata $(PUBLIC_CONTENT_METADATA) \
 		--facts-out $(QUALITY_GATE_FACTS_OUT)
 
 install: build

README.md

@@ -198,7 +198,7 @@ Prefixed with `+`, designed to be friendly for both humans and AI, with smart de
 ```bash
 lark-cli calendar +agenda
 lark-cli im +messages-send --chat-id "oc_xxx" --text "Hello"
-lark-cli docs +create --doc-format markdown --content $'<title>Weekly Report</title>\n# Progress\n- Completed feature X'
+lark-cli docs +create --api-version v2 --doc-format markdown --content $'<title>Weekly Report</title>\n# Progress\n- Completed feature X'
 ```
 
 Run `lark-cli <service> --help` to see all shortcut commands.

README.zh.md

@@ -199,7 +199,7 @@ CLI 提供三种粒度的调用方式，覆盖从快速操作到完全自定义
 ```bash
 lark-cli calendar +agenda
 lark-cli im +messages-send --chat-id "oc_xxx" --text "Hello"
-lark-cli docs +create --doc-format markdown --content $'<title>周报</title>\n# 本周进展\n- 完成了 X 功能'
+lark-cli docs +create --api-version v2 --doc-format markdown --content $'<title>周报</title>\n# 本周进展\n- 完成了 X 功能'
 ```
 
 运行 `lark-cli <service> --help` 查看所有快捷命令。

internal/qualitygate/cmd/comment-audit/main.go

@@ -1,92 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package main
-
-import (
-	"encoding/json"
-	"flag"
-	"fmt"
-	"os"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/qualitygate/publiccontent"
-	"github.com/larksuite/cli/internal/qualitygate/report"
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/internal/vfs"
-)
-
-type eventPayload struct {
-	Comment *struct {
-		Body string `json:"body"`
-	} `json:"comment"`
-	Review *struct {
-		Body string `json:"body"`
-	} `json:"review"`
-}
-
-func main() {
-	eventPath := flag.String("event", os.Getenv("GITHUB_EVENT_PATH"), "GitHub event payload path")
-	kind := flag.String("kind", os.Getenv("GITHUB_EVENT_NAME"), "GitHub event kind")
-	flag.Parse()
-
-	if *eventPath == "" {
-		fmt.Fprintln(os.Stderr, "comment-audit: --event or GITHUB_EVENT_PATH is required")
-		os.Exit(2)
-	}
-	body, err := commentBody(*eventPath)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "comment-audit: %v\n", err)
-		os.Exit(2)
-	}
-	diags := diagnostics(publiccontent.ScanComment(*kind, body))
-	if len(diags) > 0 {
-		fmt.Fprintln(os.Stderr, auditFailureSummary(len(diags)))
-	}
-	report.Print(os.Stderr, diags)
-	os.Exit(report.ExitCode(diags))
-}
-
-func auditFailureSummary(count int) string {
-	return fmt.Sprintf("post-publication audit found public content findings: %d", count)
-}
-
-func commentBody(path string) (string, error) {
-	safePath, err := validate.SafeInputPath(path)
-	if err != nil {
-		return "", errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid --event: %v", err).
-			WithParam("--event").
-			WithCause(err)
-	}
-	data, err := vfs.ReadFile(safePath)
-	if err != nil {
-		return "", err
-	}
-	var payload eventPayload
-	if err := json.Unmarshal(data, &payload); err != nil {
-		return "", err
-	}
-	switch {
-	case payload.Comment != nil:
-		return payload.Comment.Body, nil
-	case payload.Review != nil:
-		return payload.Review.Body, nil
-	default:
-		return "", nil
-	}
-}
-
-func diagnostics(items []publiccontent.Finding) []report.Diagnostic {
-	out := make([]report.Diagnostic, 0, len(items))
-	for _, item := range items {
-		out = append(out, report.Diagnostic{
-			Rule:       item.Rule,
-			Action:     item.Action,
-			File:       item.File,
-			Line:       item.Line,
-			Message:    item.Message,
-			Suggestion: item.Suggestion,
-		})
-	}
-	return out
-}

internal/qualitygate/cmd/comment-audit/main_test.go

@@ -1,70 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package main
-
-import (
-	"errors"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-)
-
-func TestCommentBodyReadsSafeRelativeEventPath(t *testing.T) {
-	dir := t.TempDir()
-	if err := writeTestFile(filepath.Join(dir, "event.json"), `{"comment":{"body":"clean comment"}}`); err != nil {
-		t.Fatal(err)
-	}
-	origDir, err := os.Getwd()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Chdir(dir); err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() {
-		_ = os.Chdir(origDir)
-	})
-
-	got, err := commentBody("event.json")
-	if err != nil {
-		t.Fatalf("commentBody() error = %v", err)
-	}
-	if got != "clean comment" {
-		t.Fatalf("comment body = %q", got)
-	}
-}
-
-func TestCommentBodyRejectsUnsafeEventPath(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "event.json")
-	if err := writeTestFile(path, `{"comment":{"body":"clean"}}`); err != nil {
-		t.Fatal(err)
-	}
-
-	_, err := commentBody(path)
-	problem, ok := errs.ProblemOf(err)
-	if err == nil || !ok {
-		t.Fatalf("commentBody(%q) error = %v, want unsafe path validation error", path, err)
-	}
-	if problem.Category != errs.CategoryValidation || problem.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("commentBody(%q) problem = %#v, want invalid argument validation", path, problem)
-	}
-	var validationErr *errs.ValidationError
-	if !errors.As(err, &validationErr) || validationErr.Param != "--event" {
-		t.Fatalf("commentBody(%q) error = %v, want --event validation param", path, err)
-	}
-}
-
-func TestAuditFailureSummaryStatesPostPublicationAudit(t *testing.T) {
-	got := auditFailureSummary(2)
-	want := "post-publication audit found public content findings: 2"
-	if got != want {
-		t.Fatalf("auditFailureSummary() = %q, want %q", got, want)
-	}
-}
-
-func writeTestFile(path, data string) error {
-	return os.WriteFile(path, []byte(data), 0o644)
-}

internal/qualitygate/cmd/quality-gate/main.go

@@ -13,7 +13,6 @@ import (
 	"github.com/larksuite/cli/internal/qualitygate/manifest"
 	"github.com/larksuite/cli/internal/qualitygate/report"
 	"github.com/larksuite/cli/internal/qualitygate/rules"
-	"github.com/larksuite/cli/internal/validate"
 )
 
 func main() {
@@ -42,7 +41,6 @@ func runCheck(args []string) int {
 	fs.StringVar(&opts.FactsOut, "facts-out", "", "write facts JSON to this path")
 	fs.StringVar(&opts.ManifestPath, "manifest", "", "hand-authored command manifest JSON")
 	fs.StringVar(&opts.CommandIndexPath, "command-index", "", "full command index JSON")
-	fs.StringVar(&opts.PublicContentMetadataPath, "public-content-metadata", "", "PR title/body metadata JSON for public content checks")
 	fs.BoolVar(&printLegacyCommandCandidates, "print-legacy-command-candidates", false, "print current non-kebab-case hand-authored command candidates")
 	fs.BoolVar(&printLegacyFlagCandidates, "print-legacy-flag-candidates", false, "print current non-kebab-case flag candidates")
 	if err := fs.Parse(args); err != nil {
@@ -50,15 +48,6 @@ func runCheck(args []string) int {
 		return 2
 	}
 
-	if opts.PublicContentMetadataPath != "" {
-		safePath, err := validate.SafeInputPath(opts.PublicContentMetadataPath)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "quality-gate check: --public-content-metadata: %v\n", err)
-			return 2
-		}
-		opts.PublicContentMetadataPath = safePath
-	}
-
 	if opts.ManifestPath == "" || opts.CommandIndexPath == "" {
 		fmt.Fprintln(os.Stderr, "quality-gate check: --manifest and --command-index are required")
 		return 2

internal/qualitygate/cmd/quality-gate/main_test.go

@@ -37,37 +37,6 @@ func TestCheckRequiresManifestInputs(t *testing.T) {
 	}
 }
 
-func TestCheckAcceptsPublicContentMetadataFlag(t *testing.T) {
-	code, stderr := runCheckCaptureStderr(t, []string{
-		"--repo", t.TempDir(),
-		"--cli-bin", "./lark-cli",
-		"--public-content-metadata", ".tmp/quality-gate/pr.json",
-	})
-	if code != 2 {
-		t.Fatalf("exit code = %d, stderr=%s", code, stderr)
-	}
-	if strings.Contains(stderr, "flag provided but not defined") {
-		t.Fatalf("public content metadata flag was not registered: %s", stderr)
-	}
-	if !strings.Contains(stderr, "--manifest and --command-index are required") {
-		t.Fatalf("stderr = %s", stderr)
-	}
-}
-
-func TestCheckRejectsUnsafePublicContentMetadataPath(t *testing.T) {
-	code, stderr := runCheckCaptureStderr(t, []string{
-		"--repo", t.TempDir(),
-		"--cli-bin", "./lark-cli",
-		"--public-content-metadata", filepath.Join(t.TempDir(), "pr.json"),
-	})
-	if code != 2 {
-		t.Fatalf("exit code = %d, stderr=%s", code, stderr)
-	}
-	if !strings.Contains(stderr, "--public-content-metadata") || !strings.Contains(stderr, "--file") {
-		t.Fatalf("stderr = %s, want unsafe public content metadata path error", stderr)
-	}
-}
-
 func TestCheckReportsManifestReadErrorsWithFlagName(t *testing.T) {
 	dir := t.TempDir()
 	manifestPath := filepath.Join(dir, "command-manifest.json")

internal/qualitygate/cmd/semantic-review/main.go

@@ -56,14 +56,6 @@ func run(args []string) int {
 		_ = semantic.WriteMarkdown(markdownOut, decision)
 		return 0
 	}
-	if reviewPath == "" && !semantic.BuildInputView(f).HasReviewableFacts() {
-		decision := finalizeDecision(block, waiverDiags, semantic.Decision{})
-		if err := writeSemanticOutputs(decisionOut, markdownOut, decision); err != nil {
-			fmt.Fprintf(os.Stderr, "semantic-review: %v\n", err)
-			return 2
-		}
-		return decisionExitCode(decision)
-	}
 	review, err := semantic.LoadOrReviewWithConfig(context.Background(), f, reviewPath, modelConfig)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "semantic-review: %v\n", err)
@@ -80,15 +72,6 @@ func run(args []string) int {
 		return 0
 	}
 	decision := semantic.DecideWithWaivers(f, review, policy, waivers)
-	decision = finalizeDecision(block, waiverDiags, decision)
-	if err := writeSemanticOutputs(decisionOut, markdownOut, decision); err != nil {
-		fmt.Fprintf(os.Stderr, "semantic-review: %v\n", err)
-		return 2
-	}
-	return decisionExitCode(decision)
-}
-
-func finalizeDecision(block bool, waiverDiags []report.Diagnostic, decision semantic.Decision) semantic.Decision {
 	decision.BlockMode = block
 	if !block && len(decision.Blockers) > 0 {
 		for i := range decision.Blockers {
@@ -98,21 +81,15 @@ func finalizeDecision(block bool, waiverDiags []report.Diagnostic, decision sema
 		decision.Blockers = nil
 	}
 	decision.SystemWarnings = append(diagnosticSystemWarnings(waiverDiags), decision.SystemWarnings...)
-	return decision
-}
-
-func writeSemanticOutputs(decisionOut, markdownOut string, decision semantic.Decision) error {
 	if err := semantic.WriteDecision(decisionOut, decision); err != nil {
-		return fmt.Errorf("write decision: %w", err)
+		fmt.Fprintf(os.Stderr, "semantic-review: write decision: %v\n", err)
+		return 2
 	}
 	if err := semantic.WriteMarkdown(markdownOut, decision); err != nil {
-		return fmt.Errorf("write markdown: %w", err)
+		fmt.Fprintf(os.Stderr, "semantic-review: write markdown: %v\n", err)
+		return 2
 	}
-	return nil
-}
-
-func decisionExitCode(decision semantic.Decision) int {
-	if decision.BlockMode && len(decision.Blockers) > 0 {
+	if block && len(decision.Blockers) > 0 {
 		return 1
 	}
 	return 0

internal/qualitygate/cmd/semantic-review/main_test.go

@@ -7,7 +7,6 @@ import (
 	"encoding/json"
 	"os"
 	"path/filepath"
-	"strings"
 	"testing"
 
 	"github.com/larksuite/cli/internal/qualitygate/facts"
@@ -212,19 +211,7 @@ func TestRunWritesSkippedDecisionForUnavailableReviewer(t *testing.T) {
 	  "allowed_base_urls": ["https://ark.ap-southeast.bytepluses.com/api/v3"]
 	}`, "")
 	factsPath := filepath.Join(t.TempDir(), "facts.json")
-	f := facts.Facts{
-		SchemaVersion: 1,
-		Skills: []facts.SkillFact{{
-			SourceFile:               "skills/lark-wiki/SKILL.md",
-			Line:                     30,
-			Changed:                  true,
-			ReferencesInvalidCommand: true,
-		}},
-	}
-	if !semantic.BuildInputView(f).HasReviewableFacts() {
-		t.Fatal("test setup must contain reviewable facts")
-	}
-	if err := f.WriteFile(factsPath); err != nil {
+	if err := (facts.Facts{SchemaVersion: 1}).WriteFile(factsPath); err != nil {
 		t.Fatalf("write facts: %v", err)
 	}
 	decisionPath := filepath.Join(t.TempDir(), "decision.json")
@@ -241,71 +228,6 @@ func TestRunWritesSkippedDecisionForUnavailableReviewer(t *testing.T) {
 	}
 }
 
-func TestRunShortCircuitsEmptySemanticInputWithoutReviewer(t *testing.T) {
-	t.Setenv("ARK_API_KEY", "")
-	t.Setenv("ARK_BASE_URL", "")
-	t.Setenv("ARK_MODEL", "")
-
-	repo := t.TempDir()
-	writeSemanticConfig(t, repo, `{
-	  "schema_version": 1,
-	  "default_enforcement": "observe",
-	  "block_categories": ["skill_quality"]
-	}`, `{
-	  "allowed": ["semantic-review-v1"],
-	  "allowed_base_urls": ["https://ark.ap-southeast.bytepluses.com/api/v3"]
-	}`, "")
-	factsPath := filepath.Join(t.TempDir(), "facts.json")
-	f := facts.Facts{
-		SchemaVersion: 1,
-		Commands: []facts.CommandFact{{
-			Path:    "service command 1",
-			Domain:  "service",
-			Changed: true,
-			Source:  "service",
-		}},
-		Outputs: []facts.OutputFact{{
-			Command:          "service command 1",
-			Domain:           "service",
-			Changed:          true,
-			Source:           "service",
-			IsList:           true,
-			HasDefaultLimit:  true,
-			HasDecisionField: true,
-		}},
-	}
-	if semantic.BuildInputView(f).HasReviewableFacts() {
-		t.Fatal("test setup must not contain reviewable facts")
-	}
-	if err := f.WriteFile(factsPath); err != nil {
-		t.Fatalf("write facts: %v", err)
-	}
-	decisionPath := filepath.Join(t.TempDir(), "decision.json")
-	markdownPath := filepath.Join(t.TempDir(), "semantic.md")
-	code := run([]string{"--repo", repo, "--facts", factsPath, "--decision-out", decisionPath, "--markdown-out", markdownPath, "--block"})
-	if code != 0 {
-		t.Fatalf("run() = %d, want clean pass", code)
-	}
-	decision := readDecision(t, decisionPath)
-	if decision.Skipped || decision.Degraded || decision.InfrastructureFailure || !decision.BlockMode {
-		t.Fatalf("expected non-degraded pass decision: %#v", decision)
-	}
-	if len(decision.SystemWarnings) != 0 || len(decision.Warnings) != 0 || len(decision.Blockers) != 0 {
-		t.Fatalf("empty semantic view should not produce findings: %#v", decision)
-	}
-	data, err := os.ReadFile(markdownPath)
-	if err != nil {
-		t.Fatalf("read markdown: %v", err)
-	}
-	markdown := string(data)
-	if !strings.Contains(markdown, "No semantic blockers.") {
-		t.Fatalf("markdown missing pass summary: %s", markdown)
-	}
-	if strings.Contains(strings.ToLower(markdown), "skipped") || strings.Contains(strings.ToLower(markdown), "degraded") {
-		t.Fatalf("markdown should not report semantic review as skipped/degraded: %s", markdown)
-	}
-}
-
 func TestRunWritesInfrastructureFailureDecisionForInvalidReviewerConfig(t *testing.T) {
 	t.Setenv("ARK_API_KEY", "test-key")
 	t.Setenv("ARK_BASE_URL", "")
@@ -321,19 +243,7 @@ func TestRunWritesInfrastructureFailureDecisionForInvalidReviewerConfig(t *testi
 	  "allowed_base_urls": ["https://ark.ap-southeast.bytepluses.com/api/v3"]
 	}`, "")
 	factsPath := filepath.Join(t.TempDir(), "facts.json")
-	f := facts.Facts{
-		SchemaVersion: 1,
-		Skills: []facts.SkillFact{{
-			SourceFile:               "skills/lark-wiki/SKILL.md",
-			Line:                     30,
-			Changed:                  true,
-			ReferencesInvalidCommand: true,
-		}},
-	}
-	if !semantic.BuildInputView(f).HasReviewableFacts() {
-		t.Fatal("test setup must contain reviewable facts")
-	}
-	if err := f.WriteFile(factsPath); err != nil {
+	if err := (facts.Facts{SchemaVersion: 1}).WriteFile(factsPath); err != nil {
 		t.Fatalf("write facts: %v", err)
 	}
 	decisionPath := filepath.Join(t.TempDir(), "decision.json")

internal/qualitygate/config/semantic/policy.json

@@ -5,8 +5,7 @@
     "error_hint",
     "default_output",
     "naming",
-    "skill_quality",
-    "public_content_leakage"
+    "skill_quality"
   ],
   "rollout_groups": [
     {
@@ -17,8 +16,7 @@
       },
       "categories": [
         "error_hint",
-        "skill_quality",
-        "public_content_leakage"
+        "skill_quality"
       ],
       "owner": "cli-owner",
       "reason": "first semantic blocking rollout only affects changed facts"

internal/qualitygate/facts/schema.go

@@ -13,15 +13,14 @@ import (
 )
 
 type Facts struct {
-	SchemaVersion int                 `json:"schema_version"`
-	Commands      []CommandFact       `json:"commands,omitempty"`
-	Skills        []SkillFact         `json:"skills,omitempty"`
-	SkillQuality  []SkillQualityFact  `json:"skill_quality,omitempty"`
-	Errors        []ErrorFact         `json:"errors,omitempty"`
-	Outputs       []OutputFact        `json:"outputs,omitempty"`
-	Examples      []CommandExample    `json:"examples,omitempty"`
-	PublicContent []PublicContentFact `json:"public_content,omitempty"`
-	Diagnostics   []DiagnosticFact    `json:"diagnostics,omitempty"`
+	SchemaVersion int                `json:"schema_version"`
+	Commands      []CommandFact      `json:"commands,omitempty"`
+	Skills        []SkillFact        `json:"skills,omitempty"`
+	SkillQuality  []SkillQualityFact `json:"skill_quality,omitempty"`
+	Errors        []ErrorFact        `json:"errors,omitempty"`
+	Outputs       []OutputFact       `json:"outputs,omitempty"`
+	Examples      []CommandExample   `json:"examples,omitempty"`
+	Diagnostics   []DiagnosticFact   `json:"diagnostics,omitempty"`
 }
 
 type CommandFact struct {
@@ -110,17 +109,6 @@ type OutputFact struct {
 	HasDecisionField bool     `json:"has_decision_field,omitempty"`
 }
 
-type PublicContentFact struct {
-	Rule       string        `json:"rule"`
-	Action     report.Action `json:"action"`
-	File       string        `json:"file"`
-	Line       int           `json:"line"`
-	Source     string        `json:"source,omitempty"`
-	Excerpt    string        `json:"excerpt,omitempty"`
-	Message    string        `json:"message,omitempty"`
-	Suggestion string        `json:"suggestion,omitempty"`
-}
-
 type DryRunRequest struct {
 	Method string              `json:"method"`
 	URL    string              `json:"url"`
@@ -218,11 +206,6 @@ func BuildWithCommandLookup(m manifest.Manifest, commandLookup manifest.Manifest
 	}
 }
 
-func WithPublicContent(f Facts, publicContent []PublicContentFact) Facts {
-	f.PublicContent = publicContent
-	return f
-}
-
 type commandScope struct {
 	Domain string
 	Source string

internal/qualitygate/facts/schema_test.go

@@ -34,7 +34,6 @@ func TestFactsSchemaCarriesGatekeeperFields(t *testing.T) {
 		Errors:        []ErrorFact{{Code: "invalid_input", Message: "bad path", Hint: "pass --file", Retryable: false, HintActionCount: 1, RequiredHint: true}},
 		Outputs:       []OutputFact{{Command: "im messages list", Fields: []string{"message_id", "sender", "create_time"}, IsList: true, HasDefaultLimit: true, HasDecisionField: true}},
 		Skills:        []SkillFact{{SourceFile: "skills/lark-doc/SKILL.md", Line: 1, DestructiveWithoutGuard: true, ScopeConflict: true}},
-		PublicContent: []PublicContentFact{{Rule: "public_content_generic_credential", Action: report.ActionReject, File: "docs/public.md", Line: 4, Excerpt: "api_key = <redacted>"}},
 	}
 	data, err := json.Marshal(f)
 	if err != nil {
@@ -44,10 +43,7 @@ func TestFactsSchemaCarriesGatekeeperFields(t *testing.T) {
 	if err := json.Unmarshal(data, &got); err != nil {
 		t.Fatalf("unmarshal facts: %v", err)
 	}
-	if !got.Errors[0].RequiredHint ||
-		got.Outputs[0].Fields[0] != "message_id" ||
-		!got.Skills[0].ScopeConflict ||
-		got.PublicContent[0].Rule != "public_content_generic_credential" {
+	if !got.Errors[0].RequiredHint || got.Outputs[0].Fields[0] != "message_id" || !got.Skills[0].ScopeConflict {
 		t.Fatalf("facts lost gatekeeper fields: %#v", got)
 	}
 }

internal/qualitygate/publiccontent/collect.go

@@ -1,343 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package publiccontent
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"sort"
-	"strconv"
-	"strings"
-)
-
-func Collect(ctx context.Context, opts Options) ([]Finding, error) {
-	metadata, err := LoadMetadata(opts.MetadataPath)
-	if err != nil {
-		return nil, err
-	}
-
-	var out []Finding
-	changedFiles, base, err := changedFiles(ctx, opts.Repo, opts.ChangedFrom)
-	if err != nil {
-		return nil, err
-	}
-	patches := map[string][]changedChunk{}
-	if base != "" {
-		patches, err = changedPatches(ctx, opts.Repo, base)
-		if err != nil {
-			return nil, err
-		}
-	}
-	for _, file := range changedFiles {
-		if !scanChangedFile(file) {
-			continue
-		}
-		for _, chunk := range patches[file] {
-			findings := scanText(file, "file", chunk.Text, isDetectorRuleFile(file))
-			for i := range findings {
-				findings[i].Line += chunk.StartLine - 1
-			}
-			out = append(out, findings...)
-			out = append(out, semanticCandidate(file, "file", chunk.Text, chunk.StartLine)...)
-		}
-		privateKeyFindings, err := scanTouchedPrivateKeyBlocks(ctx, opts.Repo, file, patches[file])
-		if err != nil {
-			return nil, err
-		}
-		out = appendUniqueFindings(out, privateKeyFindings...)
-	}
-	if base != "" {
-		commitFindings, err := scanCommitMessages(ctx, opts.Repo, base)
-		if err != nil {
-			return nil, err
-		}
-		out = append(out, commitFindings...)
-	}
-	branchName := opts.BranchName
-	if branchName == "" {
-		branchName = metadata.Branch
-	}
-	if branchName == "" {
-		branchName = branchFromEnv()
-	}
-	if branchName == "" {
-		branchName = currentBranch(ctx, opts.Repo)
-	}
-	if branchName != "" {
-		out = append(out, scanText("branch", "branch", branchName, false)...)
-	}
-	out = append(out, scanMetadata(metadata)...)
-	sort.SliceStable(out, func(i, j int) bool {
-		if out[i].File != out[j].File {
-			return out[i].File < out[j].File
-		}
-		if out[i].Line != out[j].Line {
-			return out[i].Line < out[j].Line
-		}
-		return out[i].Rule < out[j].Rule
-	})
-	return out, nil
-}
-
-func currentBranch(ctx context.Context, repo string) string {
-	data, err := gitOutput(ctx, repo, "branch", "--show-current")
-	if err != nil {
-		return ""
-	}
-	return strings.TrimSpace(string(data))
-}
-
-func branchFromEnv() string {
-	for _, key := range []string{"PR_BRANCH", "GITHUB_HEAD_REF", "GITHUB_REF_NAME"} {
-		if value := strings.TrimSpace(os.Getenv(key)); value != "" {
-			return value
-		}
-	}
-	return ""
-}
-
-func changedFiles(ctx context.Context, repo, changedFrom string) ([]string, string, error) {
-	if changedFrom == "" {
-		return nil, "", nil
-	}
-	baseBytes, err := gitOutput(ctx, repo, "merge-base", changedFrom, "HEAD")
-	if err != nil {
-		return nil, "", err
-	}
-	base := strings.TrimSpace(string(baseBytes))
-	files, err := diffFileNames(ctx, repo, base)
-	if err != nil {
-		return nil, "", err
-	}
-	sort.Strings(files)
-	return files, base, nil
-}
-
-func diffFileNames(ctx context.Context, repo, base string) ([]string, error) {
-	data, err := gitOutput(ctx, repo, "diff", "--name-only", "-z", "--diff-filter=ACMR", base+"..HEAD")
-	if err != nil {
-		return nil, err
-	}
-	var files []string
-	for _, file := range bytes.Split(data, []byte{0}) {
-		if len(file) == 0 {
-			continue
-		}
-		files = append(files, filepath.ToSlash(string(file)))
-	}
-	return files, nil
-}
-
-var detectorFixtureExclusions = map[string]bool{
-	"internal/qualitygate/publiccontent/collect_test.go": true,
-	"internal/qualitygate/publiccontent/rules.go":        true,
-	"internal/qualitygate/publiccontent/scan.go":         true,
-	"internal/qualitygate/publiccontent/scan_test.go":    true,
-}
-
-func scanChangedFile(file string) bool {
-	normalized := strings.TrimPrefix(strings.ReplaceAll(file, "\\", "/"), "./")
-	return !detectorFixtureExclusions[normalized]
-}
-
-type changedChunk struct {
-	StartLine int
-	Text      string
-}
-
-func (c changedChunk) endLine() int {
-	lines := strings.Count(strings.TrimRight(c.Text, "\n"), "\n") + 1
-	if lines < 1 {
-		lines = 1
-	}
-	return c.StartLine + lines - 1
-}
-
-func changedPatches(ctx context.Context, repo, base string) (map[string][]changedChunk, error) {
-	files, err := diffFileNames(ctx, repo, base)
-	if err != nil {
-		return nil, err
-	}
-	data, err := gitOutput(ctx, repo, "diff", "--no-ext-diff", "--unified=0", "--diff-filter=ACMR", base+"..HEAD")
-	if err != nil {
-		return nil, err
-	}
-	out := map[string][]changedChunk{}
-	var file string
-	var chunk *changedChunk
-	nextLine := 0
-	nextFile := 0
-	flush := func() {
-		if file == "" || chunk == nil || chunk.Text == "" {
-			chunk = nil
-			return
-		}
-		out[file] = append(out[file], *chunk)
-		chunk = nil
-	}
-	for _, raw := range strings.Split(string(data), "\n") {
-		switch {
-		case strings.HasPrefix(raw, "diff --git "):
-			flush()
-			file = ""
-			if nextFile < len(files) {
-				file = files[nextFile]
-				nextFile++
-			}
-		case strings.HasPrefix(raw, "@@ "):
-			flush()
-			start, ok := parseNewHunkStart(raw)
-			if !ok {
-				nextLine = 0
-				continue
-			}
-			nextLine = start
-			chunk = &changedChunk{StartLine: start}
-		case strings.HasPrefix(raw, "+") && !strings.HasPrefix(raw, "+++"):
-			if chunk == nil {
-				chunk = &changedChunk{StartLine: max(nextLine, 1)}
-			}
-			chunk.Text += strings.TrimPrefix(raw, "+") + "\n"
-			nextLine++
-		case strings.HasPrefix(raw, "-"):
-			continue
-		default:
-			if chunk != nil && strings.HasPrefix(raw, `\ No newline at end of file`) {
-				continue
-			}
-			flush()
-		}
-	}
-	flush()
-	return out, nil
-}
-
-func parseNewHunkStart(header string) (int, bool) {
-	parts := strings.Split(header, " ")
-	for _, part := range parts {
-		if !strings.HasPrefix(part, "+") {
-			continue
-		}
-		raw := strings.TrimPrefix(part, "+")
-		if before, _, ok := strings.Cut(raw, ","); ok {
-			raw = before
-		}
-		start, err := strconv.Atoi(raw)
-		return start, err == nil && start > 0
-	}
-	return 0, false
-}
-
-func scanCommitMessages(ctx context.Context, repo, base string) ([]Finding, error) {
-	data, err := gitOutput(ctx, repo, "log", "--format=%H%x00%B%x00", base+"..HEAD")
-	if err != nil {
-		return nil, err
-	}
-	parts := bytes.Split(data, []byte{0})
-	var out []Finding
-	for i := 0; i+1 < len(parts); i += 2 {
-		sha := strings.TrimSpace(string(parts[i]))
-		body := string(parts[i+1])
-		if sha == "" || body == "" {
-			continue
-		}
-		short := sha
-		if len(short) > 12 {
-			short = short[:12]
-		}
-		out = append(out, scanText("commit:"+short, "commit", body, false)...)
-		out = append(out, semanticCandidate("commit:"+short, "commit", body, 1)...)
-	}
-	return out, nil
-}
-
-type lineRange struct {
-	Start int
-	End   int
-}
-
-func scanTouchedPrivateKeyBlocks(ctx context.Context, repo, file string, chunks []changedChunk) ([]Finding, error) {
-	if len(chunks) == 0 {
-		return nil, nil
-	}
-	data, err := gitOutput(ctx, repo, "show", "HEAD:"+file)
-	if err != nil {
-		return nil, err
-	}
-	var added []lineRange
-	for _, chunk := range chunks {
-		added = append(added, lineRange{Start: chunk.StartLine, End: chunk.endLine()})
-	}
-	var out []Finding
-	for _, block := range privateKeyBlocks(string(data)) {
-		if !rangesIntersectAny(block, added) {
-			continue
-		}
-		out = append(out, newFinding("public_content_private_key_block", file, block.Start, "file", "private key block"))
-	}
-	return out, nil
-}
-
-func privateKeyBlocks(text string) []lineRange {
-	lines := strings.Split(text, "\n")
-	var out []lineRange
-	inPrivateKey := false
-	start := 0
-	for i, line := range lines {
-		lineNo := i + 1
-		if !inPrivateKey && strings.Contains(line, privateKeyBeginPrefix) && strings.Contains(line, privateKeyMarker) {
-			inPrivateKey = true
-			start = lineNo
-		}
-		if inPrivateKey && strings.Contains(line, privateKeyEndPrefix) && strings.Contains(line, privateKeyMarker) {
-			out = append(out, lineRange{Start: start, End: lineNo})
-			inPrivateKey = false
-		}
-	}
-	return out
-}
-
-func rangesIntersectAny(block lineRange, ranges []lineRange) bool {
-	for _, r := range ranges {
-		if block.Start <= r.End && r.Start <= block.End {
-			return true
-		}
-	}
-	return false
-}
-
-func appendUniqueFindings(items []Finding, additions ...Finding) []Finding {
-	for _, addition := range additions {
-		duplicate := false
-		for _, item := range items {
-			if item.Rule == addition.Rule &&
-				item.File == addition.File &&
-				item.Line == addition.Line &&
-				item.Source == addition.Source {
-				duplicate = true
-				break
-			}
-		}
-		if !duplicate {
-			items = append(items, addition)
-		}
-	}
-	return items
-}
-
-func gitOutput(ctx context.Context, repo string, args ...string) ([]byte, error) {
-	cmd := exec.CommandContext(ctx, "git", args...)
-	cmd.Dir = repo
-	var stdout, stderr bytes.Buffer
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-	if err := cmd.Run(); err != nil {
-		return nil, fmt.Errorf("git %s: %w\n%s", strings.Join(args, " "), err, stderr.Bytes())
-	}
-	return stdout.Bytes(), nil
-}

internal/qualitygate/publiccontent/collect_test.go

@@ -1,885 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package publiccontent
-
-import (
-	"context"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestCollectScansOnlyCurrentContributionAndMetadata(t *testing.T) {
-	repo := t.TempDir()
-	runGit(t, repo, "init")
-	runGit(t, repo, "config", "user.email", "test@example.com")
-	runGit(t, repo, "config", "user.name", "Test User")
-
-	writeFile(t, filepath.Join(repo, "baseline.md"), `BASE_`+`TOKEN="baseline-only"
-`)
-	runGit(t, repo, "add", "baseline.md")
-	runGit(t, repo, "commit", "-m", "base")
-
-	writeFile(t, filepath.Join(repo, "docs", "public.md"), `# Public change
-
-api_`+`key = "example-public-key"
-`)
-	runGit(t, repo, "add", "docs/public.md")
-	runGit(t, repo, "commit", "-m", "add public doc", "-m", "Change"+"-Id: I0123456789abcdef0123456789abcdef01234567")
-
-	metadataPath := filepath.Join(repo, "pr-metadata.json")
-	writeFile(t, metadataPath, `{"title":"publish public docs","body":"Reviewed`+`-on: https://review.example.test/c/project/+/123"}`)
-
-	got, err := Collect(context.Background(), Options{
-		Repo:         repo,
-		ChangedFrom:  "HEAD~1",
-		MetadataPath: metadataPath,
-	})
-	if err != nil {
-		t.Fatalf("Collect() error = %v", err)
-	}
-
-	rules := findingRules(got)
-	for _, want := range []string{
-		"public_content_generic_credential",
-		"public_content_change_id_trailer",
-		"public_content_reviewed_on_trailer",
-	} {
-		if !rules[want] {
-			t.Fatalf("missing rule %s in findings %#v", want, got)
-		}
-	}
-	for _, item := range got {
-		if item.File == "baseline.md" {
-			t.Fatalf("collector scanned unchanged baseline file: %#v", got)
-		}
-	}
-}
-
-func TestCollectScansOnlyChangedLinesInChangedFiles(t *testing.T) {
-	repo := t.TempDir()
-	runGit(t, repo, "init")
-	runGit(t, repo, "config", "user.email", "test@example.com")
-	runGit(t, repo, "config", "user.name", "Test User")
-
-	writeFile(t, filepath.Join(repo, "docs", "workflow.md"), "SECRET_TOKEN=legacy-example\npublic baseline\n")
-	runGit(t, repo, "add", "docs/workflow.md")
-	runGit(t, repo, "commit", "-m", "base")
-
-	writeFile(t, filepath.Join(repo, "docs", "workflow.md"), "SECRET_TOKEN=legacy-example\npublic baseline\nnew public line\n")
-	runGit(t, repo, "add", "docs/workflow.md")
-	runGit(t, repo, "commit", "-m", "add public line")
-
-	metadataPath := filepath.Join(repo, "pr-metadata.json")
-	writeFile(t, metadataPath, `{}`)
-
-	got, err := Collect(context.Background(), Options{
-		Repo:         repo,
-		ChangedFrom:  "HEAD~1",
-		MetadataPath: metadataPath,
-	})
-	if err != nil {
-		t.Fatalf("Collect() error = %v", err)
-	}
-	for _, item := range got {
-		if item.Rule == "public_content_generic_credential" && item.File == "docs/workflow.md" {
-			t.Fatalf("collector scanned unchanged legacy line in changed file: %#v", got)
-		}
-	}
-}
-
-func TestCollectSemanticCandidatesStoreSanitizedReviewText(t *testing.T) {
-	repo := t.TempDir()
-	runGit(t, repo, "init")
-	runGit(t, repo, "config", "user.email", "test@example.com")
-	runGit(t, repo, "config", "user.name", "Test User")
-
-	writeFile(t, filepath.Join(repo, "docs", "public.md"), "base\n")
-	runGit(t, repo, "add", "docs/public.md")
-	runGit(t, repo, "commit", "-m", "base")
-
-	raw := "private launch plan for alpha-service rollout on Friday with SERVICE_" + "TOKEN=real-" + "secret-value"
-	writeFile(t, filepath.Join(repo, "docs", "public.md"), "base\n"+raw+"\n")
-	runGit(t, repo, "add", "docs/public.md")
-	runGit(t, repo, "commit", "-m", "add semantic candidate")
-
-	metadataPath := filepath.Join(repo, "pr-metadata.json")
-	writeFile(t, metadataPath, `{}`)
-
-	got, err := Collect(context.Background(), Options{
-		Repo:         repo,
-		ChangedFrom:  "HEAD~1",
-		MetadataPath: metadataPath,
-	})
-	if err != nil {
-		t.Fatalf("Collect() error = %v", err)
-	}
-	var found bool
-	for _, item := range got {
-		if item.Rule != "public_content_semantic_candidate" || item.File != "docs/public.md" {
-			continue
-		}
-		found = true
-		if !strings.Contains(item.Excerpt, "alpha-service rollout on Friday") {
-			t.Fatalf("semantic candidate should include sanitized review text, got %#v", item)
-		}
-		if strings.Contains(item.Excerpt, "real-"+"secret-value") {
-			t.Fatalf("semantic candidate leaked credential value: %#v", item)
-		}
-		if !strings.Contains(item.Excerpt, "SERVICE_TOKEN=<redacted>") {
-			t.Fatalf("semantic candidate should redact credentials in review text, got %#v", item)
-		}
-		if !strings.Contains(item.Excerpt, "semantic signals") || !strings.Contains(item.Excerpt, "roadmap_timing") {
-			t.Fatalf("semantic candidate excerpt should preserve semantic signals, got %#v", item)
-		}
-	}
-	if !found {
-		t.Fatalf("missing semantic candidate in findings %#v", got)
-	}
-}
-
-func TestCollectSemanticCandidatesDoNotLeakWhitespaceCredentialTail(t *testing.T) {
-	repo := newGitRepo(t)
-	writeFile(t, filepath.Join(repo, "docs", "public.md"), "base\n")
-	runGit(t, repo, "add", "docs/public.md")
-	runGit(t, repo, "commit", "-m", "base")
-
-	raw := "private launch plan for internal rollout on Friday with SERVICE_" + "TOKEN=\"real " + "secret value\""
-	writeFile(t, filepath.Join(repo, "docs", "public.md"), "base\n"+raw+"\n")
-	runGit(t, repo, "add", "docs/public.md")
-	runGit(t, repo, "commit", "-m", "add semantic candidate")
-
-	got := collectFromPreviousCommit(t, repo)
-	for _, item := range got {
-		if item.Rule != "public_content_semantic_candidate" || item.File != "docs/public.md" {
-			continue
-		}
-		if strings.Contains(item.Excerpt, "secret value") || strings.Contains(item.Excerpt, "real "+"secret value") {
-			t.Fatalf("semantic candidate leaked credential tail: %#v", item)
-		}
-		if !strings.Contains(item.Excerpt, "SERVICE_TOKEN=<redacted>") {
-			t.Fatalf("semantic candidate should redact full credential assignment, got %#v", item)
-		}
-		return
-	}
-	t.Fatalf("missing semantic candidate in findings %#v", got)
-}
-
-func TestCollectJSONBearerHeadersDoNotLeakIntoSemanticCandidates(t *testing.T) {
-	repo := newGitRepo(t)
-	writeFile(t, filepath.Join(repo, "docs", "public.md"), "base\n")
-	runGit(t, repo, "add", "docs/public.md")
-	runGit(t, repo, "commit", "-m", "base")
-
-	token := "abcdefghijklmnopqrstuvwxyz"
-	raw := "private launch plan for internal rollout on Friday with " +
-		`{"headers":{"Authorization":"Bearer ` + token + `"}}`
-	writeFile(t, filepath.Join(repo, "docs", "public.md"), "base\n"+raw+"\n")
-	runGit(t, repo, "add", "docs/public.md")
-	runGit(t, repo, "commit", "-m", "add json bearer")
-
-	got := collectFromPreviousCommit(t, repo)
-	requireFinding(t, got, "docs/public.md", "public_content_bearer_header")
-	for _, item := range got {
-		if item.File != "docs/public.md" {
-			continue
-		}
-		if strings.Contains(item.Excerpt, token) {
-			t.Fatalf("finding leaked JSON bearer token: %#v", item)
-		}
-	}
-}
-
-func TestCollectDetectsQuotedJSONCredentialAssignments(t *testing.T) {
-	repo := newGitRepo(t)
-	writeFile(t, filepath.Join(repo, "docs", "public.json"), "{}\n")
-	runGit(t, repo, "add", "docs/public.json")
-	runGit(t, repo, "commit", "-m", "base")
-
-	writeFile(t, filepath.Join(repo, "docs", "public.json"), strings.Join([]string{
-		`{"access_` + `token":"real-json-token"}`,
-		`{"client_` + `secret": "real ` + `secret value"}`,
-		`{"tenantAccess` + `Token":"real-tenant-camel-token"}`,
-		`{"github` + `Token":"real-github-token"}`,
-		`{"vendorApi` + `Key":"real-vendor-key"}`,
-		`{"slackBot` + `Token":"xoxb-real-token"}`,
-	}, "\n")+"\n")
-	runGit(t, repo, "add", "docs/public.json")
-	runGit(t, repo, "commit", "-m", "add json config")
-
-	got := collectFromPreviousCommit(t, repo)
-	var count int
-	for _, item := range got {
-		if item.File == "docs/public.json" && item.Rule == "public_content_generic_credential" {
-			count++
-			for _, forbidden := range []string{
-				"real-json-token",
-				"real secret value",
-				"real-tenant-camel-token",
-				"real-github-token",
-				"real-vendor-key",
-				"xoxb-real-token",
-			} {
-				if strings.Contains(item.Excerpt, forbidden) {
-					t.Fatalf("JSON credential finding leaked value %q in excerpt %q", forbidden, item.Excerpt)
-				}
-			}
-		}
-	}
-	if count != 6 {
-		t.Fatalf("JSON credential findings = %d, want 6: %#v", count, got)
-	}
-}
-
-func TestCollectAllowsBenignJSONTokenFields(t *testing.T) {
-	repo := newGitRepo(t)
-	writeFile(t, filepath.Join(repo, "docs", "public.json"), "{}\n")
-	runGit(t, repo, "add", "docs/public.json")
-	runGit(t, repo, "commit", "-m", "base")
-
-	writeFile(t, filepath.Join(repo, "docs", "public.json"), strings.Join([]string{
-		`{"tokenizer":"cl100k_base"}`,
-		`{"token_count": 42}`,
-		`{"page_token":"next"}`,
-		`{"next_page_token":"next"}`,
-		`{"file_token":"file-example"}`,
-		`{"doc_token":"doc-example"}`,
-		`{"node_token":"node-example"}`,
-		`{"wiki_token":"wikcn_public_doc_example"}`,
-		`{"folder_token":"folder-example"}`,
-		`{"obj_token":"obj-example"}`,
-		`{"spreadsheet_token":"sheet-example"}`,
-		`{"parent_node_token":"parent-example"}`,
-		`{"origin_node_token":"origin-example"}`,
-		`{"drive_route_token":"route-example"}`,
-		`{"token":"<wiki_token>"}`,
-		`{"token":"wiki_token"}`,
-		`{"token_url":"https://example.com/oauth/token"}`,
-		`{"token_endpoint":"https://example.com/oauth/token"}`,
-		`{"token_format":"Bearer"}`,
-		`{"secret_name":"public-example-secret"}`,
-		`{"base_token":"base-example"}`,
-		`{"app_token":"app-example"}`,
-		`{"sync_token":"sync-example"}`,
-		`{"parent_token":"parent-example"}`,
-		`{"target_token":"target-example"}`,
-		`{"parent_file_token":"parent-file-example"}`,
-		`{"refresh_token_expires_in": 7200}`,
-		`{"access_token_expires_in": 7200}`,
-		`{"token_expires_in": 7200}`,
-		`{"token_status":"active"}`,
-	}, "\n")+"\n")
-	runGit(t, repo, "add", "docs/public.json")
-	runGit(t, repo, "commit", "-m", "add benign json token fields")
-
-	got := collectFromPreviousCommit(t, repo)
-	for _, item := range got {
-		if item.File == "docs/public.json" && item.Rule == "public_content_generic_credential" {
-			t.Fatalf("benign JSON token field should not be credential finding: %#v", got)
-		}
-	}
-}
-
-func TestCollectDetectsAngleWrappedRealisticCredentialValues(t *testing.T) {
-	repo := newGitRepo(t)
-	writeFile(t, filepath.Join(repo, "docs", "config.yaml"), "base: true\n")
-	runGit(t, repo, "add", "docs/config.yaml")
-	runGit(t, repo, "commit", "-m", "base")
-	stripeLike := "sk_" + "live_1234567890abcdef"
-	patLike := "gh" + "p_1234567890abcdef1234567890abcdef1234"
-
-	writeFile(t, filepath.Join(repo, "docs", "config.yaml"), strings.Join([]string{
-		"API_KEY: <" + stripeLike + ">",
-		"SECRET_TOKEN: <" + patLike + ">",
-		"CLIENT_SECRET: <real-client-secret-value>",
-	}, "\n")+"\n")
-	runGit(t, repo, "add", "docs/config.yaml")
-	runGit(t, repo, "commit", "-m", "add credential config")
-
-	got := collectFromPreviousCommit(t, repo)
-	var count int
-	for _, item := range got {
-		if item.File == "docs/config.yaml" && item.Rule == "public_content_generic_credential" {
-			count++
-		}
-	}
-	if count != 3 {
-		t.Fatalf("angle-wrapped realistic credential findings = %d, want 3: %#v", count, got)
-	}
-}
-
-func TestCollectDetectsCredentialShapedValuesUnderBenignKeys(t *testing.T) {
-	repo := newGitRepo(t)
-	writeFile(t, filepath.Join(repo, "docs", "public.json"), "{}\n")
-	runGit(t, repo, "add", "docs/public.json")
-	runGit(t, repo, "commit", "-m", "base")
-	stripeLike := "sk_" + "live_1234567890abcdef"
-	patLike := "gh" + "p_1234567890abcdef1234567890abcdef1234"
-
-	writeFile(t, filepath.Join(repo, "docs", "public.json"), strings.Join([]string{
-		`{"access_token_expires_in":"` + patLike + `"}`,
-		`{"refresh_token_expires_in":"` + stripeLike + `"}`,
-		`{"client_secret_status":"real-client-secret-value"}`,
-		`{"client_secret_name":"real-client-secret-value"}`,
-		`{"app_token":"` + patLike + `"}`,
-		`{"sync_token":"` + stripeLike + `"}`,
-		`{"target_token":"real-client-secret-value"}`,
-	}, "\n")+"\n")
-	runGit(t, repo, "add", "docs/public.json")
-	runGit(t, repo, "commit", "-m", "add credential-shaped benign fields")
-
-	got := collectFromPreviousCommit(t, repo)
-	var count int
-	for _, item := range got {
-		if item.File == "docs/public.json" && item.Rule == "public_content_generic_credential" {
-			count++
-		}
-	}
-	if count != 7 {
-		t.Fatalf("credential-shaped benign-key findings = %d, want 7: %#v", count, got)
-	}
-}
-
-func TestCollectDetectsBareIdentifierCredentialsWithMetadataSuffixes(t *testing.T) {
-	repo := newGitRepo(t)
-	writeFile(t, filepath.Join(repo, "docs", "config.yaml"), "base: true\n")
-	runGit(t, repo, "add", "docs/config.yaml")
-	runGit(t, repo, "commit", "-m", "base")
-
-	writeFile(t, filepath.Join(repo, "docs", "config.yaml"), strings.Join([]string{
-		"API_KEY_NAME: prod_key",
-		"CLIENT_SECRET_NAME: prod_secret",
-		"SECRET_STATUS: prod_secret",
-	}, "\n")+"\n")
-	runGit(t, repo, "add", "docs/config.yaml")
-	runGit(t, repo, "commit", "-m", "add credential config")
-
-	got := collectFromPreviousCommit(t, repo)
-	var count int
-	for _, item := range got {
-		if item.File == "docs/config.yaml" && item.Rule == "public_content_generic_credential" {
-			count++
-		}
-	}
-	if count != 3 {
-		t.Fatalf("metadata-suffixed bare credential findings = %d, want 3: %#v", count, got)
-	}
-}
-
-func TestCollectDetectsAccessKeyCredentials(t *testing.T) {
-	repo := newGitRepo(t)
-	writeFile(t, filepath.Join(repo, "docs", "config.yaml"), "base: true\n")
-	runGit(t, repo, "add", "docs/config.yaml")
-	runGit(t, repo, "commit", "-m", "base")
-	accessKey := "AK" + "IAIOSFODNN7EXAMPX"
-
-	writeFile(t, filepath.Join(repo, "docs", "config.yaml"), strings.Join([]string{
-		"AWS_ACCESS_KEY_ID: " + accessKey,
-		"ACCESS_KEY_ID: " + accessKey,
-		"ACCESS_KEY: " + accessKey,
-	}, "\n")+"\n")
-	runGit(t, repo, "add", "docs/config.yaml")
-	runGit(t, repo, "commit", "-m", "add access key config")
-
-	got := collectFromPreviousCommit(t, repo)
-	var count int
-	for _, item := range got {
-		if item.File != "docs/config.yaml" || item.Rule != "public_content_generic_credential" {
-			continue
-		}
-		count++
-		if strings.Contains(item.Excerpt, "AKIAIOSFODNN7EXAMPX") {
-			t.Fatalf("access key finding leaked value in excerpt %q", item.Excerpt)
-		}
-	}
-	if count != 3 {
-		t.Fatalf("access key credential findings = %d, want 3: %#v", count, got)
-	}
-}
-
-func TestCollectDetectsPrivateKeyAssignments(t *testing.T) {
-	repo := newGitRepo(t)
-	writeFile(t, filepath.Join(repo, "docs", "config.yaml"), "base: true\n")
-	runGit(t, repo, "add", "docs/config.yaml")
-	runGit(t, repo, "commit", "-m", "base")
-
-	privateKey := "LS0tLS1CRUdJTiBQUklWQVRFIEtFWS0tLS0t"
-	writeFile(t, filepath.Join(repo, "docs", "config.yaml"), strings.Join([]string{
-		"PRIVATE_KEY: " + privateKey,
-		"SSH_PRIVATE_KEY: " + privateKey,
-		"JWT_PRIVATE_KEY: " + privateKey,
-		"SIGNING_PRIVATE_KEY: " + privateKey,
-	}, "\n")+"\n")
-	runGit(t, repo, "add", "docs/config.yaml")
-	runGit(t, repo, "commit", "-m", "add private key config")
-
-	got := collectFromPreviousCommit(t, repo)
-	var count int
-	for _, item := range got {
-		if item.File != "docs/config.yaml" || item.Rule != "public_content_generic_credential" {
-			continue
-		}
-		count++
-		if strings.Contains(item.Excerpt, privateKey) {
-			t.Fatalf("private key finding leaked value in excerpt %q", item.Excerpt)
-		}
-	}
-	if count != 4 {
-		t.Fatalf("private key assignment findings = %d, want 4: %#v", count, got)
-	}
-}
-
-func TestCollectDetectsCredentialValuesThatLookLikeBareIdentifiers(t *testing.T) {
-	repo := newGitRepo(t)
-	writeFile(t, filepath.Join(repo, "docs", "config.yaml"), "base: true\n")
-	runGit(t, repo, "add", "docs/config.yaml")
-	runGit(t, repo, "commit", "-m", "base")
-
-	writeFile(t, filepath.Join(repo, "docs", "config.yaml"), strings.Join([]string{
-		"API_KEY_OPENAI: prod_key",
-		"CLIENT_SECRET_GOOGLE: prod_secret",
-		"TOKEN_GITHUB: github_token",
-		"APP_PASSWORD_PROD: prod_password",
-	}, "\n")+"\n")
-	runGit(t, repo, "add", "docs/config.yaml")
-	runGit(t, repo, "commit", "-m", "add credential config")
-
-	got := collectFromPreviousCommit(t, repo)
-	var count int
-	for _, item := range got {
-		if item.File == "docs/config.yaml" && item.Rule == "public_content_generic_credential" {
-			count++
-		}
-	}
-	if count != 4 {
-		t.Fatalf("bare identifier credential findings = %d, want 4: %#v", count, got)
-	}
-}
-
-func TestCollectAllowsBenignUnquotedTokenFields(t *testing.T) {
-	repo := newGitRepo(t)
-	writeFile(t, filepath.Join(repo, "docs", "config.yaml"), "base: true\n")
-	runGit(t, repo, "add", "docs/config.yaml")
-	runGit(t, repo, "commit", "-m", "base")
-
-	writeFile(t, filepath.Join(repo, "docs", "config.yaml"), strings.Join([]string{
-		"tokens: 128",
-		"token_type: bearer",
-		"max_tokens: 2000",
-		"completion_tokens: 200",
-		"prompt_tokens: 100",
-	}, "\n")+"\n")
-	runGit(t, repo, "add", "docs/config.yaml")
-	runGit(t, repo, "commit", "-m", "add benign token config")
-
-	got := collectFromPreviousCommit(t, repo)
-	for _, item := range got {
-		if item.File == "docs/config.yaml" && item.Rule == "public_content_generic_credential" {
-			t.Fatalf("benign unquoted token field should not be credential finding: %#v", got)
-		}
-	}
-}
-
-func TestCollectDetectsCredentialPhraseBeforeEnvironmentSuffix(t *testing.T) {
-	repo := newGitRepo(t)
-	writeFile(t, filepath.Join(repo, "docs", "config.yaml"), "base: true\n")
-	runGit(t, repo, "add", "docs/config.yaml")
-	runGit(t, repo, "commit", "-m", "base")
-
-	writeFile(t, filepath.Join(repo, "docs", "config.yaml"), strings.Join([]string{
-		"API_KEY_OPENAI: real-openai-key",
-		"TOKEN_GITHUB: real-github-token",
-		"CLIENT_SECRET_GOOGLE: real-google-secret",
-		"SECRET_KEY_BASE: real-secret-key-base",
-		"APP_PASSWORD_PROD: real-prod-password",
-	}, "\n")+"\n")
-	runGit(t, repo, "add", "docs/config.yaml")
-	runGit(t, repo, "commit", "-m", "add credential config")
-
-	got := collectFromPreviousCommit(t, repo)
-	var count int
-	for _, item := range got {
-		if item.File != "docs/config.yaml" || item.Rule != "public_content_generic_credential" {
-			continue
-		}
-		count++
-		for _, forbidden := range []string{
-			"real-openai-key",
-			"real-github-token",
-			"real-google-secret",
-			"real-secret-key-base",
-			"real-prod-password",
-		} {
-			if strings.Contains(item.Excerpt, forbidden) {
-				t.Fatalf("credential finding leaked value %q in excerpt %q", forbidden, item.Excerpt)
-			}
-		}
-	}
-	if count != 5 {
-		t.Fatalf("credential suffix variants findings = %d, want 5: %#v", count, got)
-	}
-}
-
-func TestCollectDetectsPrivateKeyWhenOnlyEndIsAdded(t *testing.T) {
-	repo := newGitRepo(t)
-
-	writeFile(t, filepath.Join(repo, "docs", "key.pem"), privateKeyBegin()+"legacy-body\n")
-	runGit(t, repo, "add", "docs/key.pem")
-	runGit(t, repo, "commit", "-m", "base")
-
-	writeFile(t, filepath.Join(repo, "docs", "key.pem"), privateKeyBegin()+"legacy-body\nnew-body\n"+privateKeyEnd())
-	runGit(t, repo, "add", "docs/key.pem")
-	runGit(t, repo, "commit", "-m", "complete key")
-
-	got := collectFromPreviousCommit(t, repo)
-	requireFinding(t, got, "docs/key.pem", "public_content_private_key_block")
-}
-
-func TestCollectDetectsPrivateKeyWhenOnlyBeginIsAdded(t *testing.T) {
-	repo := newGitRepo(t)
-
-	writeFile(t, filepath.Join(repo, "docs", "key.pem"), "legacy-body\n"+privateKeyEnd())
-	runGit(t, repo, "add", "docs/key.pem")
-	runGit(t, repo, "commit", "-m", "base")
-
-	writeFile(t, filepath.Join(repo, "docs", "key.pem"), privateKeyBegin()+"legacy-body\n"+privateKeyEnd())
-	runGit(t, repo, "add", "docs/key.pem")
-	runGit(t, repo, "commit", "-m", "complete key")
-
-	got := collectFromPreviousCommit(t, repo)
-	requireFinding(t, got, "docs/key.pem", "public_content_private_key_block")
-}
-
-func TestCollectDetectsPrivateKeyWhenOnlyBodyIsAdded(t *testing.T) {
-	repo := newGitRepo(t)
-
-	writeFile(t, filepath.Join(repo, "docs", "key.pem"), privateKeyBegin()+privateKeyEnd())
-	runGit(t, repo, "add", "docs/key.pem")
-	runGit(t, repo, "commit", "-m", "base")
-
-	writeFile(t, filepath.Join(repo, "docs", "key.pem"), privateKeyBegin()+"new-body\n"+privateKeyEnd())
-	runGit(t, repo, "add", "docs/key.pem")
-	runGit(t, repo, "commit", "-m", "add body")
-
-	got := collectFromPreviousCommit(t, repo)
-	requireFinding(t, got, "docs/key.pem", "public_content_private_key_block")
-}
-
-func TestCollectIgnoresUntouchedHistoricalPrivateKey(t *testing.T) {
-	repo := newGitRepo(t)
-
-	writeFile(t, filepath.Join(repo, "docs", "key.pem"), privateKeyBegin()+"legacy-body\n"+privateKeyEnd())
-	runGit(t, repo, "add", "docs/key.pem")
-	runGit(t, repo, "commit", "-m", "base")
-
-	writeFile(t, filepath.Join(repo, "docs", "key.pem"), privateKeyBegin()+"legacy-body\n"+privateKeyEnd())
-	writeFile(t, filepath.Join(repo, "docs", "public.md"), "public docs update\n")
-	runGit(t, repo, "add", "docs/public.md")
-	runGit(t, repo, "commit", "-m", "docs update")
-
-	got := collectFromPreviousCommit(t, repo)
-	for _, item := range got {
-		if item.File == "docs/key.pem" && item.Rule == "public_content_private_key_block" {
-			t.Fatalf("collector reported untouched historical private key: %#v", got)
-		}
-	}
-}
-
-func TestCollectIgnoresDeletedPrivateKeyLine(t *testing.T) {
-	repo := newGitRepo(t)
-
-	writeFile(t, filepath.Join(repo, "docs", "key.pem"), privateKeyBegin()+"legacy-body\n"+privateKeyEnd())
-	runGit(t, repo, "add", "docs/key.pem")
-	runGit(t, repo, "commit", "-m", "base")
-
-	writeFile(t, filepath.Join(repo, "docs", "key.pem"), privateKeyBegin()+privateKeyEnd())
-	runGit(t, repo, "add", "docs/key.pem")
-	runGit(t, repo, "commit", "-m", "remove body")
-
-	got := collectFromPreviousCommit(t, repo)
-	for _, item := range got {
-		if item.File == "docs/key.pem" && item.Rule == "public_content_private_key_block" {
-			t.Fatalf("collector reported delete-only private key cleanup: %#v", got)
-		}
-	}
-}
-
-func TestCollectSkipsOnlyKnownQualityGateFixtureFiles(t *testing.T) {
-	repo := t.TempDir()
-	runGit(t, repo, "init")
-	runGit(t, repo, "config", "user.email", "test@example.com")
-	runGit(t, repo, "config", "user.name", "Test User")
-
-	writeFile(t, filepath.Join(repo, "README.md"), "base\n")
-	runGit(t, repo, "add", "README.md")
-	runGit(t, repo, "commit", "-m", "base")
-
-	writeFile(t, filepath.Join(repo, "internal", "qualitygate", "publiccontent", "collect_test.go"), "SECRET_TOKEN=fixture\n")
-	writeFile(t, filepath.Join(repo, "internal", "qualitygate", "publiccontent", "scan_test.go"), "SECRET_TOKEN=fixture\n")
-	writeFile(t, filepath.Join(repo, "internal", "qualitygate", "publiccontent", "scan.go"), "const privateKeyFixture = \""+privateKeyBeginPrefix+privateKeyMarker+"\"\n")
-	writeFile(t, filepath.Join(repo, "internal", "qualitygate", "publiccontent", "rules.go"), "markers := []string{\"generated with automation\"}\n")
-	writeFile(t, filepath.Join(repo, "tests", "e2e", "new-public-workflow.test.sh"), "SECRET_TOKEN=real-leak\n")
-	runGit(t, repo, "add", ".")
-	runGit(t, repo, "commit", "-m", "add scanner fixtures")
-
-	metadataPath := filepath.Join(repo, "pr-metadata.json")
-	writeFile(t, metadataPath, `{}`)
-
-	got, err := Collect(context.Background(), Options{
-		Repo:         repo,
-		ChangedFrom:  "HEAD~1",
-		MetadataPath: metadataPath,
-	})
-	if err != nil {
-		t.Fatalf("Collect() error = %v", err)
-	}
-	var foundOrdinaryTestLeak bool
-	for _, item := range got {
-		switch item.File {
-		case "internal/qualitygate/publiccontent/collect_test.go",
-			"internal/qualitygate/publiccontent/scan.go",
-			"internal/qualitygate/publiccontent/scan_test.go",
-			"internal/qualitygate/publiccontent/rules.go":
-			t.Fatalf("collector scanned known fixture or detector implementation file: %#v", got)
-		}
-		if item.File == "tests/e2e/new-public-workflow.test.sh" && item.Rule == "public_content_generic_credential" {
-			foundOrdinaryTestLeak = true
-		}
-	}
-	if !foundOrdinaryTestLeak {
-		t.Fatalf("collector should still scan ordinary test files for real leaks: %#v", got)
-	}
-}
-
-func TestScanChangedFileDocumentsFixtureExclusions(t *testing.T) {
-	excluded := []string{
-		"internal/qualitygate/publiccontent/collect_test.go",
-		"internal/qualitygate/publiccontent/rules.go",
-		"internal/qualitygate/publiccontent/scan.go",
-		"internal/qualitygate/publiccontent/scan_test.go",
-	}
-	for _, file := range excluded {
-		if scanChangedFile(file) {
-			t.Fatalf("scanChangedFile(%q) = true, want false for detector fixture/implementation path", file)
-		}
-	}
-
-	included := []string{
-		"internal/qualitygate/publiccontent/new_test.go",
-		"tests/e2e/new-public-workflow.test.sh",
-		"docs/public.md",
-	}
-	for _, file := range included {
-		if !scanChangedFile(file) {
-			t.Fatalf("scanChangedFile(%q) = false, want true", file)
-		}
-	}
-}
-
-func TestCollectScansAddedLinesInSpecialPathNames(t *testing.T) {
-	repo := newGitRepo(t)
-	writeFile(t, filepath.Join(repo, "docs", "old.md"), "base\n")
-	runGit(t, repo, "add", ".")
-	runGit(t, repo, "commit", "-m", "base")
-
-	writeFile(t, filepath.Join(repo, "docs", "has space.md"), "SECRET_TOKEN=space-value\n")
-	writeFile(t, filepath.Join(repo, `weird"quote.md`), "SECRET_TOKEN=quote-value\n")
-	runGit(t, repo, "mv", "docs/old.md", "docs/new name.md")
-	writeFile(t, filepath.Join(repo, "docs", "new name.md"), "base\nSECRET_TOKEN=rename-value\n")
-	runGit(t, repo, "add", ".")
-	runGit(t, repo, "commit", "-m", "add special paths")
-
-	got := collectFromPreviousCommit(t, repo)
-	requireFinding(t, got, "docs/has space.md", "public_content_generic_credential")
-	requireFinding(t, got, `weird"quote.md`, "public_content_generic_credential")
-	requireFinding(t, got, "docs/new name.md", "public_content_generic_credential")
-}
-
-func TestCollectScansBranchNameAsWarning(t *testing.T) {
-	repo := t.TempDir()
-	metadataPath := filepath.Join(repo, "pr-metadata.json")
-	writeFile(t, metadataPath, `{"branch":"bot/public-doc-update"}`)
-	got, err := Collect(context.Background(), Options{
-		Repo:         repo,
-		MetadataPath: metadataPath,
-	})
-	if err != nil {
-		t.Fatalf("Collect() error = %v", err)
-	}
-	if len(got) != 1 || got[0].Rule != "public_content_automation_branch" {
-		t.Fatalf("branch findings = %#v", got)
-	}
-}
-
-func TestCollectUsesExplicitBranchNameWhenDetached(t *testing.T) {
-	repo := newGitRepo(t)
-	writeFile(t, filepath.Join(repo, "README.md"), "base\n")
-	runGit(t, repo, "add", "README.md")
-	runGit(t, repo, "commit", "-m", "base")
-	runGit(t, repo, "checkout", "-b", "bot/public-doc-update")
-	writeFile(t, filepath.Join(repo, "docs.md"), "safe docs\n")
-	runGit(t, repo, "add", "docs.md")
-	runGit(t, repo, "commit", "-m", "docs")
-	head := strings.TrimSpace(string(runGitOutput(t, repo, "rev-parse", "HEAD")))
-	runGit(t, repo, "checkout", "--detach", head)
-
-	metadataPath := filepath.Join(repo, "pr-metadata.json")
-	writeFile(t, metadataPath, `{}`)
-	got, err := Collect(context.Background(), Options{
-		Repo:         repo,
-		MetadataPath: metadataPath,
-		BranchName:   "bot/public-doc-update",
-	})
-	if err != nil {
-		t.Fatalf("Collect() error = %v", err)
-	}
-	requireFinding(t, got, "branch", "public_content_automation_branch")
-}
-
-func TestCollectUsesBranchEnvironmentWhenDetached(t *testing.T) {
-	repo := newGitRepo(t)
-	writeFile(t, filepath.Join(repo, "README.md"), "base\n")
-	runGit(t, repo, "add", "README.md")
-	runGit(t, repo, "commit", "-m", "base")
-	runGit(t, repo, "checkout", "-b", "bot/public-env-update")
-	writeFile(t, filepath.Join(repo, "docs.md"), "safe docs\n")
-	runGit(t, repo, "add", "docs.md")
-	runGit(t, repo, "commit", "-m", "docs")
-	head := strings.TrimSpace(string(runGitOutput(t, repo, "rev-parse", "HEAD")))
-	runGit(t, repo, "checkout", "--detach", head)
-	t.Setenv("GITHUB_HEAD_REF", "bot/public-env-update")
-
-	metadataPath := filepath.Join(repo, "pr-metadata.json")
-	writeFile(t, metadataPath, `{}`)
-	got, err := Collect(context.Background(), Options{
-		Repo:         repo,
-		MetadataPath: metadataPath,
-	})
-	if err != nil {
-		t.Fatalf("Collect() error = %v", err)
-	}
-	requireFinding(t, got, "branch", "public_content_automation_branch")
-}
-
-func TestCollectPreservesFindingAttributionForChangedLines(t *testing.T) {
-	repo := newGitRepo(t)
-	writeFile(t, filepath.Join(repo, "docs", "auth.md"), "intro\n")
-	runGit(t, repo, "add", "docs/auth.md")
-	runGit(t, repo, "commit", "-m", "base")
-
-	writeFile(t, filepath.Join(repo, "docs", "auth.md"), "intro\nAuthorization: Bearer abcdefghijklmnopqrstuvwxyz\n")
-	runGit(t, repo, "add", "docs/auth.md")
-	runGit(t, repo, "commit", "-m", "add auth docs")
-
-	got := collectFromPreviousCommit(t, repo)
-	for _, item := range got {
-		if item.Rule == "public_content_bearer_header" {
-			if item.File != "docs/auth.md" || item.Line != 2 || item.Source != "file" {
-				t.Fatalf("changed-line attribution = %#v", item)
-			}
-			return
-		}
-	}
-	t.Fatalf("missing bearer finding: %#v", got)
-}
-
-func TestAppendUniqueFindingsDeduplicatesByRuleFileLineAndSource(t *testing.T) {
-	base := []Finding{newFinding("public_content_private_key_block", "docs/key.pem", 1, "file", "private key block")}
-	got := appendUniqueFindings(base,
-		newFinding("public_content_private_key_block", "docs/key.pem", 1, "file", "private key block"),
-		newFinding("public_content_private_key_block", "docs/key.pem", 2, "file", "private key block"),
-	)
-	if len(got) != 2 {
-		t.Fatalf("appendUniqueFindings len = %d, want 2: %#v", len(got), got)
-	}
-}
-
-func newGitRepo(t *testing.T) string {
-	t.Helper()
-	repo := t.TempDir()
-	runGit(t, repo, "init")
-	runGit(t, repo, "config", "user.email", "test@example.com")
-	runGit(t, repo, "config", "user.name", "Test User")
-	return repo
-}
-
-func privateKeyBegin() string {
-	return privateKeyBeginPrefix + privateKeyMarker + "\n"
-}
-
-func privateKeyEnd() string {
-	return privateKeyEndPrefix + privateKeyMarker + "\n"
-}
-
-func collectFromPreviousCommit(t *testing.T, repo string) []Finding {
-	t.Helper()
-	metadataPath := filepath.Join(repo, "pr-metadata.json")
-	writeFile(t, metadataPath, `{}`)
-	got, err := Collect(context.Background(), Options{
-		Repo:         repo,
-		ChangedFrom:  "HEAD~1",
-		MetadataPath: metadataPath,
-	})
-	if err != nil {
-		t.Fatalf("Collect() error = %v", err)
-	}
-	return got
-}
-
-func requireFinding(t *testing.T, got []Finding, file, rule string) {
-	t.Helper()
-	for _, item := range got {
-		if item.File == file && item.Rule == rule {
-			return
-		}
-	}
-	t.Fatalf("missing %s in %s findings: %#v", rule, file, got)
-}
-
-func TestCollectRequiresValidMetadataJSON(t *testing.T) {
-	repo := t.TempDir()
-	metadataPath := filepath.Join(repo, "pr-metadata.json")
-	writeFile(t, metadataPath, `{"title":`)
-
-	_, err := Collect(context.Background(), Options{Repo: repo, MetadataPath: metadataPath})
-	if err == nil || !strings.Contains(err.Error(), "public content metadata") {
-		t.Fatalf("Collect() error = %v, want metadata parse error", err)
-	}
-}
-
-func runGit(t *testing.T, repo string, args ...string) {
-	t.Helper()
-	if len(args) > 0 && args[0] == "commit" {
-		args = append([]string{"commit", "--no-verify"}, args[1:]...)
-	}
-	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)
-	}
-}
-
-func runGitOutput(t *testing.T, repo string, args ...string) []byte {
-	t.Helper()
-	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)
-	}
-	return out
-}
-
-func writeFile(t *testing.T, path, data string) {
-	t.Helper()
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(path, []byte(data), 0o644); err != nil {
-		t.Fatal(err)
-	}
-}

internal/qualitygate/publiccontent/comment_audit.go

@@ -1,11 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package publiccontent
-
-func ScanComment(kind, body string) []Finding {
-	if kind == "" {
-		kind = "comment"
-	}
-	return scanText(kind, "comment", body, false)
-}

internal/qualitygate/publiccontent/comment_audit_test.go

@@ -1,19 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package publiccontent
-
-import "testing"
-
-func TestScanCommentAuditsPublishedCommentBodies(t *testing.T) {
-	got := ScanComment("issue_comment", `The published comment included /tmp/harness`+`-agent/run and CCM`+`-Harness: stage-4`)
-	rules := findingRules(got)
-	if !rules["public_content_harness_metadata"] || !rules["public_content_ccm_harness_trailer"] {
-		t.Fatalf("comment audit findings = %#v", got)
-	}
-	for _, item := range got {
-		if item.File != "issue_comment" {
-			t.Fatalf("comment finding file = %q, want issue_comment", item.File)
-		}
-	}
-}

internal/qualitygate/publiccontent/metadata.go

@@ -1,45 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package publiccontent
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"github.com/larksuite/cli/internal/vfs"
-)
-
-func LoadMetadata(path string) (Metadata, error) {
-	if path == "" {
-		return Metadata{}, nil
-	}
-	data, err := vfs.ReadFile(path)
-	if err != nil {
-		return Metadata{}, fmt.Errorf("public content metadata: %w", err)
-	}
-	if len(data) == 0 {
-		return Metadata{}, nil
-	}
-	var out Metadata
-	if err := json.Unmarshal(data, &out); err != nil {
-		return Metadata{}, fmt.Errorf("public content metadata: %w", err)
-	}
-	return out, nil
-}
-
-func scanMetadata(m Metadata) []Finding {
-	text := ""
-	if m.Title != "" {
-		text += "title: " + m.Title + "\n"
-	}
-	if m.Body != "" {
-		text += "body:\n" + m.Body + "\n"
-	}
-	if text == "" {
-		return nil
-	}
-	out := scanText("pull_request_metadata", "metadata", text, false)
-	out = append(out, semanticCandidate("pull_request_metadata", "metadata", text, 1)...)
-	return out
-}

internal/qualitygate/publiccontent/metadata_test.go

@@ -1,22 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package publiccontent
-
-import (
-	"path/filepath"
-	"testing"
-)
-
-func TestLoadMetadataReadsTitleAndBody(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "metadata.json")
-	writeFile(t, path, `{"title":"public change","body":"pass`+`word = \"example-password\""}`)
-
-	got, err := LoadMetadata(path)
-	if err != nil {
-		t.Fatalf("LoadMetadata() error = %v", err)
-	}
-	if got.Title != "public change" || got.Body == "" {
-		t.Fatalf("metadata = %#v", got)
-	}
-}

internal/qualitygate/publiccontent/rules.go

@@ -1,441 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package publiccontent
-
-import (
-	"net/url"
-	"path/filepath"
-	"regexp"
-	"strings"
-
-	"github.com/larksuite/cli/internal/qualitygate/report"
-)
-
-var (
-	credentialAssignmentRE = regexp.MustCompile(`(?i)["']?\b[A-Za-z0-9_-]*(?:api[_-]?key|access[_-]?key|private[_-]?key|secret|password|passwd|token|webhook|access[_-]?token|client[_-]?secret)[A-Za-z0-9_-]*\b["']?\s*[:=]\s*(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'|(\$\([^)]*\))|(\$\{\{[^}]+\}\})|([^"'\s,}\]]+))`)
-	jwtLikeRE              = regexp.MustCompile(`\b[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b`)
-	credentialURLRE        = regexp.MustCompile(`(?i)\b[a-z][a-z0-9+.-]*://[^/\s:@]*:[^@\s/]+@[^)\s]+`)
-	bearerHeaderRE         = regexp.MustCompile(`(?i)(?:\bAuthorization\s*:\s*Bearer\s+|["']Authorization["']\s*:\s*["']Bearer\s+)[A-Za-z0-9._+/=-]{12,}`)
-	semanticBearerHeaderRE = regexp.MustCompile(`(?i)(?:\bAuthorization\s*:\s*Bearer\s+[^"'\s,}\]]+|["']Authorization["']\s*:\s*["']Bearer\s+[^"'\\\s,}\]]+)`)
-	changeIDTrailerRE      = regexp.MustCompile(`(?i)^\s*Change-Id:\s*\S+`)
-	reviewedOnTrailerRE    = regexp.MustCompile(`(?i)^\s*Reviewed-on:\s*\S+`)
-	ccmHarnessTrailerRE    = regexp.MustCompile(`(?i)\bCCM-Harness:\s*\S+`)
-	privateIPv4RE          = regexp.MustCompile(`\b(?:10\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}|192\.168\.[0-9]{1,3}\.[0-9]{1,3}|172\.(?:1[6-9]|2[0-9]|3[0-1])\.[0-9]{1,3}\.[0-9]{1,3})\b`)
-	automationBranchRE     = regexp.MustCompile(`(?i)(^|/)(bot|automation)[-/]`)
-)
-
-func actionForRule(rule string) report.Action {
-	switch rule {
-	case "public_content_generic_credential",
-		"public_content_private_key_block",
-		"public_content_jwt_like_token",
-		"public_content_bearer_header",
-		"public_content_credential_url",
-		"public_content_change_id_trailer",
-		"public_content_reviewed_on_trailer",
-		"public_content_provenance_marker",
-		"public_content_detector_fingerprint",
-		"public_content_harness_metadata",
-		"public_content_ccm_harness_trailer":
-		return report.ActionReject
-	case "public_content_private_ipv4",
-		"public_content_automation_branch":
-		return report.ActionWarning
-	default:
-		return report.ActionWarning
-	}
-}
-
-func isPlaceholderValue(value string) bool {
-	trimmed := strings.Trim(value, `"'`)
-	normalized := strings.ToLower(trimmed)
-	if normalized == "" ||
-		normalized == "=" ||
-		percentWrappedPlaceholder(normalized) ||
-		angleWrappedPlaceholder(normalized) ||
-		urlWithAnglePlaceholder(normalized) ||
-		isCredentialReferenceValue(trimmed) {
-		return true
-	}
-	return namedPlaceholderValue(normalized)
-}
-
-func namedPlaceholderValue(value string) bool {
-	switch value {
-	case "...", "placeholder", "redacted", "<redacted>", "xxxx", "test-secret":
-		return true
-	}
-	return strings.Contains(value, "cli_example") || allXPlaceholder(value)
-}
-
-func allXPlaceholder(value string) bool {
-	if len(value) < 4 {
-		return false
-	}
-	for _, r := range value {
-		if r != 'x' {
-			return false
-		}
-	}
-	return true
-}
-
-func urlWithAnglePlaceholder(value string) bool {
-	if !strings.Contains(value, "://") ||
-		!strings.Contains(value, "<") ||
-		!strings.Contains(value, ">") {
-		return false
-	}
-	return !urlRemainderLooksCredentialLike(removeAnglePlaceholders(value))
-}
-
-func removeAnglePlaceholders(value string) string {
-	var out strings.Builder
-	for len(value) > 0 {
-		start := strings.Index(value, "<")
-		if start < 0 {
-			out.WriteString(value)
-			break
-		}
-		out.WriteString(value[:start])
-		end := strings.Index(value[start+1:], ">")
-		if end < 0 {
-			out.WriteString(value[start:])
-			break
-		}
-		value = value[start+end+2:]
-	}
-	return out.String()
-}
-
-func urlRemainderLooksCredentialLike(value string) bool {
-	normalized := strings.ToLower(value)
-	for _, marker := range []string{
-		"secret",
-		"token",
-		"password",
-		"passwd",
-		"api_key",
-		"apikey",
-		"private_key",
-		"privatekey",
-		"client_secret",
-		"clientsecret",
-	} {
-		if strings.Contains(normalized, marker) {
-			return true
-		}
-	}
-	for _, part := range strings.FieldsFunc(normalized, func(r rune) bool {
-		return !((r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == '_' || r == '-')
-	}) {
-		if credentialShapedIdentifier(part) || longCredentialSegment(part) {
-			return true
-		}
-	}
-	return false
-}
-
-func longCredentialSegment(value string) bool {
-	if len(value) < 16 {
-		return false
-	}
-	var hasLetter, hasDigit bool
-	for _, r := range value {
-		switch {
-		case r >= 'a' && r <= 'z':
-			hasLetter = true
-		case r >= '0' && r <= '9':
-			hasDigit = true
-		case r == '_' || r == '-':
-		default:
-			return false
-		}
-	}
-	return hasLetter || hasDigit
-}
-
-func isCredentialReferenceValue(value string) bool {
-	normalized := strings.ToLower(value)
-	switch {
-	case strings.HasPrefix(normalized, "${{"):
-		return githubExpressionReference(normalized)
-	case strings.HasPrefix(normalized, "$("):
-		return !commandSubstitutionLooksCredentialLike(normalized)
-	case strings.HasPrefix(normalized, "process.env."):
-		return credentialReferenceIdentifier(strings.TrimPrefix(normalized, "process.env."))
-	case strings.HasPrefix(normalized, "${"):
-		return credentialReferenceIdentifier(strings.TrimSuffix(strings.TrimPrefix(normalized, "${"), "}"))
-	case strings.HasPrefix(value, "$"):
-		return credentialReferenceIdentifier(strings.TrimPrefix(normalized, "$"))
-	default:
-		return false
-	}
-}
-
-func commandSubstitutionLooksCredentialLike(value string) bool {
-	if !strings.HasPrefix(value, "$(") || !strings.HasSuffix(value, ")") {
-		return false
-	}
-	inner := strings.TrimSuffix(strings.TrimPrefix(value, "$("), ")")
-	for _, part := range strings.FieldsFunc(inner, func(r rune) bool {
-		return !((r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == '_' || r == '-')
-	}) {
-		if credentialShapedIdentifier(part) || longCredentialSegment(part) {
-			return true
-		}
-	}
-	return false
-}
-
-func githubExpressionReference(value string) bool {
-	if !strings.HasPrefix(value, "${{") || !strings.HasSuffix(value, "}}") {
-		return false
-	}
-	expr := strings.TrimSpace(strings.TrimSuffix(strings.TrimPrefix(value, "${{"), "}}"))
-	switch {
-	case strings.HasPrefix(expr, "secrets."):
-		return dottedReferenceIdentifier(strings.TrimPrefix(expr, "secrets."))
-	case strings.HasPrefix(expr, "env."):
-		return dottedReferenceIdentifier(strings.TrimPrefix(expr, "env."))
-	case strings.HasPrefix(expr, "vars."):
-		return dottedReferenceIdentifier(strings.TrimPrefix(expr, "vars."))
-	case expr == "github.token":
-		return true
-	default:
-		return false
-	}
-}
-
-func dottedReferenceIdentifier(value string) bool {
-	if value == "" {
-		return false
-	}
-	for _, part := range strings.Split(value, ".") {
-		if !referenceIdentifier(part) {
-			return false
-		}
-	}
-	return true
-}
-
-func credentialReferenceIdentifier(value string) bool {
-	return referenceIdentifier(value) && !credentialShapedIdentifier(value)
-}
-
-func referenceIdentifier(value string) bool {
-	if value == "" {
-		return false
-	}
-	for i, r := range value {
-		switch {
-		case r >= 'a' && r <= 'z':
-		case r >= '0' && r <= '9' && i > 0:
-		case r == '_' && i > 0:
-		default:
-			return false
-		}
-	}
-	return true
-}
-
-func angleWrappedPlaceholder(value string) bool {
-	if len(value) < 3 || !strings.HasPrefix(value, "<") || !strings.HasSuffix(value, ">") {
-		return false
-	}
-	return anglePlaceholderIdentifier(strings.Trim(value, "<>"))
-}
-
-func percentWrappedPlaceholder(value string) bool {
-	if len(value) < 3 || !strings.HasPrefix(value, "%") || !strings.HasSuffix(value, "%") {
-		return false
-	}
-	inner := strings.Trim(value, "%")
-	return delimitedPlaceholderIdentifier(inner) && !credentialShapedIdentifier(inner)
-}
-
-func delimitedPlaceholderIdentifier(value string) bool {
-	if value == "" {
-		return false
-	}
-	for _, r := range value {
-		if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == '_' || r == '-' {
-			continue
-		}
-		return false
-	}
-	return true
-}
-
-func anglePlaceholderIdentifier(value string) bool {
-	if value == "" {
-		return false
-	}
-	for _, r := range value {
-		if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == '_' || r == '-' {
-			continue
-		}
-		return false
-	}
-	if credentialShapedIdentifier(value) {
-		return false
-	}
-	switch value {
-	case "token",
-		"id",
-		"userid",
-		"openid",
-		"key",
-		"secret",
-		"password",
-		"api-key",
-		"user-id",
-		"open-id",
-		"client-secret",
-		"access-token",
-		"refresh-token",
-		"auth-token",
-		"bearer-token",
-		"session-token",
-		"service-token":
-		return true
-	}
-	for _, suffix := range []string{"_token", "_id", "_key", "_secret", "_password"} {
-		if strings.HasSuffix(value, suffix) {
-			return true
-		}
-	}
-	for _, suffix := range []string{"-token", "-id", "-key", "-secret", "-password"} {
-		if strings.HasSuffix(value, suffix) {
-			return true
-		}
-	}
-	return false
-}
-
-func credentialShapedValue(value string) bool {
-	normalized := strings.ToLower(strings.Trim(value, `"'<>`))
-	return credentialShapedIdentifier(normalized)
-}
-
-func credentialShapedIdentifier(value string) bool {
-	switch {
-	case strings.HasPrefix(value, "sk_live_"),
-		strings.HasPrefix(value, "sk_test_"),
-		strings.HasPrefix(value, "ghp_"),
-		strings.HasPrefix(value, "gho_"),
-		strings.HasPrefix(value, "ghu_"),
-		strings.HasPrefix(value, "github_pat_"),
-		strings.HasPrefix(value, "xoxb_"),
-		strings.HasPrefix(value, "xoxp_"),
-		strings.HasPrefix(value, "xoxa_"):
-		return true
-	case strings.HasPrefix(value, "real-") &&
-		(strings.Contains(value, "secret") ||
-			strings.Contains(value, "token") ||
-			strings.Contains(value, "key") ||
-			strings.Contains(value, "password")):
-		return true
-	default:
-		return false
-	}
-}
-
-func resourceTokenPlaceholderValue(value string) bool {
-	normalized := strings.ToLower(strings.Trim(value, `"'`))
-	switch normalized {
-	case "wiki_token",
-		"folder_token",
-		"obj_token",
-		"spreadsheet_token",
-		"file_token",
-		"doc_token",
-		"node_token",
-		"parent_node_token",
-		"origin_node_token",
-		"drive_route_token":
-		return true
-	default:
-		return minuteTokenFixturePlaceholder(normalized)
-	}
-}
-
-func minuteTokenFixturePlaceholder(value string) bool {
-	if value == "minute_no_meta" {
-		return true
-	}
-	suffix, ok := strings.CutPrefix(value, "minute_")
-	if !ok || suffix == "" {
-		return false
-	}
-	for _, r := range suffix {
-		if r < '0' || r > '9' {
-			return false
-		}
-	}
-	return true
-}
-
-func provenanceMarker(line string) bool {
-	normalized := strings.ToLower(line)
-	markers := []string{
-		"generat" + "ed by tool",
-		"creat" + "ed by tool",
-		"generat" + "ed by automation",
-		"creat" + "ed by automation",
-		"machine-" + "generated",
-		"generated with automated",
-		"generated with automation",
-		"🤖 generated",
-	}
-	for _, marker := range markers {
-		if strings.Contains(normalized, marker) {
-			return true
-		}
-	}
-	if strings.HasPrefix(normalized, "co-authored-by:") &&
-		(strings.Contains(normalized, "<bot@") ||
-			strings.Contains(normalized, " bot@") ||
-			strings.Contains(normalized, "[bot]") ||
-			strings.Contains(normalized, "automation") ||
-			strings.Contains(normalized, "automated-code-assistant")) {
-		return true
-	}
-	return false
-}
-
-// Detector fingerprint checks are intentionally scoped to public rule/config
-// files. They do not try to hide this package's implementation; they prevent
-// publishing reusable detector identifiers in external-facing rule bundles.
-func isDetectorRuleFile(path string) bool {
-	normalized := filepath.ToSlash(path)
-	base := filepath.Base(normalized)
-	return base == ".gitleaks.toml" ||
-		strings.Contains(normalized, "public-rules/") ||
-		strings.Contains(normalized, "public_rules/")
-}
-
-func detectorFingerprint(line string) bool {
-	normalized := strings.ToLower(line)
-	fingerprints := []string{
-		strings.Join([]string{"public", "content", "leakage"}, "-"),
-		strings.Join([]string{"public", "content", "detector"}, "-"),
-		"publiccontent",
-	}
-	for _, fingerprint := range fingerprints {
-		if strings.Contains(normalized, fingerprint) {
-			return true
-		}
-	}
-	return false
-}
-
-func redactCredentialURL(raw string) string {
-	u, err := url.Parse(raw)
-	if err != nil || u.User == nil {
-		return "<credential-url>"
-	}
-	u.User = url.UserPassword("<user>", "<redacted>")
-	return u.String()
-}

internal/qualitygate/publiccontent/scan.go

@@ -1,797 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package publiccontent
-
-import (
-	"fmt"
-	"path/filepath"
-	"sort"
-	"strings"
-	"unicode"
-)
-
-const (
-	privateKeyBeginPrefix = "-----" + "BEGIN "
-	privateKeyEndPrefix   = "-----" + "END "
-	privateKeyMarker      = "PRIVATE " + "KEY-----"
-)
-
-func ScanFile(path string, data []byte) []Finding {
-	return scanText(filepath.ToSlash(path), "file", string(data), isDetectorRuleFile(path))
-}
-
-func semanticCandidate(file, source, text string, line int) []Finding {
-	excerpt := redactedSemanticExcerpt(text)
-	if excerpt == "" {
-		return nil
-	}
-	return []Finding{newFinding("public_content_semantic_candidate", file, line, source, excerpt)}
-}
-
-func scanText(file, source, text string, detectorFile bool) []Finding {
-	var out []Finding
-	lines := strings.Split(text, "\n")
-	inPrivateKey := false
-	privateKeyLine := 0
-	for i, line := range lines {
-		lineNo := i + 1
-		if strings.Contains(line, privateKeyBeginPrefix) && strings.Contains(line, privateKeyMarker) {
-			inPrivateKey = true
-			privateKeyLine = lineNo
-		}
-		if inPrivateKey && strings.Contains(line, privateKeyEndPrefix) && strings.Contains(line, privateKeyMarker) {
-			out = append(out, newFinding("public_content_private_key_block", file, privateKeyLine, source, "private key block"))
-			inPrivateKey = false
-		}
-		for _, match := range credentialAssignmentRE.FindAllStringSubmatch(line, -1) {
-			if !isCredentialAssignmentMatch(match[0]) {
-				continue
-			}
-			value := credentialAssignmentValue(match)
-			keyName, _ := normalizedCredentialAssignmentKey(match[0])
-			if value == "" ||
-				isNonSecretLiteralValue(value) ||
-				isBenignCodeCredentialExpression(file, value) ||
-				isPlaceholderValue(value) ||
-				isResourceTokenPlaceholderAssignment(keyName, value) {
-				continue
-			}
-			if looksLikeEqualityComparison(value) {
-				continue
-			}
-			out = append(out, newFinding("public_content_generic_credential", file, lineNo, source, redactAssignment(match[0])))
-		}
-		for _, match := range jwtLikeRE.FindAllString(line, -1) {
-			if isSchemaDottedIdentifier(line, match) {
-				continue
-			}
-			out = append(out, newFinding("public_content_jwt_like_token", file, lineNo, source, redactToken(match)))
-		}
-		for range bearerHeaderRE.FindAllString(line, -1) {
-			out = append(out, newFinding("public_content_bearer_header", file, lineNo, source, "Authorization: Bearer <redacted>"))
-		}
-		for _, match := range credentialURLRE.FindAllString(line, -1) {
-			if isPlaceholderCredentialURL(match) {
-				continue
-			}
-			out = append(out, newFinding("public_content_credential_url", file, lineNo, source, redactCredentialURL(match)))
-		}
-		for _, match := range privateIPv4RE.FindAllString(line, -1) {
-			out = append(out, newFinding("public_content_private_ipv4", file, lineNo, source, match))
-		}
-		if source == "branch" && automationBranchRE.MatchString(line) {
-			out = append(out, newFinding("public_content_automation_branch", file, lineNo, source, "automation branch marker"))
-		}
-		switch {
-		case changeIDTrailerRE.MatchString(line):
-			out = append(out, newFinding("public_content_change_id_trailer", file, lineNo, source, "Change-Id: <redacted>"))
-		case reviewedOnTrailerRE.MatchString(line):
-			out = append(out, newFinding("public_content_reviewed_on_trailer", file, lineNo, source, "Reviewed-on: <redacted>"))
-		case ccmHarnessTrailerRE.MatchString(line):
-			out = append(out, newFinding("public_content_ccm_harness_trailer", file, lineNo, source, "CCM-Harness: <redacted>"))
-		}
-		if provenanceMarker(line) {
-			out = append(out, newFinding("public_content_provenance_marker", file, lineNo, source, "provenance marker"))
-		}
-		if strings.Contains(line, "/tmp/harness-agent") {
-			out = append(out, newFinding("public_content_harness_metadata", file, lineNo, source, "/tmp/harness-agent"))
-		}
-		if detectorFile && detectorFingerprint(line) {
-			out = append(out, newFinding("public_content_detector_fingerprint", file, lineNo, source, "public detector fingerprint"))
-		}
-	}
-	sort.SliceStable(out, func(i, j int) bool {
-		if out[i].File != out[j].File {
-			return out[i].File < out[j].File
-		}
-		if out[i].Line != out[j].Line {
-			return out[i].Line < out[j].Line
-		}
-		return out[i].Rule < out[j].Rule
-	})
-	return out
-}
-
-func isCredentialAssignmentMatch(match string) bool {
-	name, value, ok := normalizedCredentialAssignment(match)
-	if !ok {
-		return false
-	}
-	if isWebhookCredentialKey(name) && webhookAssignmentValueLooksCredentialLike(value) {
-		return true
-	}
-	if isBenignTokenField(name) && !credentialShapedValue(value) {
-		return false
-	}
-	return isExplicitCredentialKey(name)
-}
-
-func normalizedCredentialAssignmentKey(match string) (string, bool) {
-	key, _, ok := normalizedCredentialAssignment(match)
-	return key, ok
-}
-
-func normalizedCredentialAssignment(match string) (string, string, bool) {
-	key, ok := credentialAssignmentKey(match)
-	if !ok {
-		return "", "", false
-	}
-	key = strings.TrimSpace(key)
-	if key == "" {
-		return "", "", false
-	}
-	submatches := credentialAssignmentRE.FindStringSubmatch(match)
-	return normalizedCredentialKey(strings.Trim(key, `"'`)), credentialAssignmentValue(submatches), true
-}
-
-func normalizedCredentialKey(key string) string {
-	key = strings.TrimSpace(key)
-	var out []rune
-	var prev rune
-	for i, r := range key {
-		if r == '-' {
-			r = '_'
-		}
-		if i > 0 && isCredentialKeyBoundary(prev, r) {
-			out = append(out, '_')
-		}
-		out = append(out, unicode.ToLower(r))
-		prev = r
-	}
-	key = string(out)
-	key = strings.ReplaceAll(key, "-", "_")
-	return key
-}
-
-func isCredentialKeyBoundary(prev, current rune) bool {
-	if prev == '_' || current == '_' {
-		return false
-	}
-	return (unicode.IsLower(prev) || unicode.IsDigit(prev)) && unicode.IsUpper(current)
-}
-
-func isBenignTokenField(key string) bool {
-	if isTokenMetricField(key) ||
-		isTokenMetadataField(key) ||
-		isResourceTokenField(key) ||
-		isPaginationOrSyncTokenField(key) {
-		return true
-	}
-	return false
-}
-
-func isTokenMetricField(key string) bool {
-	switch key {
-	case "tokenizer",
-		"token_count",
-		"tokens",
-		"max_tokens",
-		"completion_tokens",
-		"prompt_tokens":
-		return true
-	default:
-		return false
-	}
-}
-
-func isTokenMetadataField(key string) bool {
-	switch key {
-	case "access_token_expires_in",
-		"refresh_token_expires_in",
-		"token_expires_in",
-		"token_status",
-		"token_type",
-		"token_url",
-		"token_endpoint",
-		"token_format",
-		"secret_name":
-		return true
-	default:
-		return false
-	}
-}
-
-func isPaginationOrSyncTokenField(key string) bool {
-	switch key {
-	case "page_token",
-		"next_page_token",
-		"sync_token":
-		return true
-	default:
-		return false
-	}
-}
-
-func isResourceTokenField(key string) bool {
-	if !strings.HasSuffix(key, "_token") {
-		return false
-	}
-	prefix := strings.TrimSuffix(key, "_token")
-	switch prefix {
-	case "app",
-		"base",
-		"board",
-		"doc",
-		"drive_route",
-		"file",
-		"folder",
-		"host_node",
-		"minute",
-		"node",
-		"obj",
-		"origin_node",
-		"parent",
-		"parent_file",
-		"parent_node",
-		"share",
-		"spreadsheet",
-		"target",
-		"wiki":
-		return true
-	default:
-		return false
-	}
-}
-
-func isResourceTokenPlaceholderAssignment(key, value string) bool {
-	switch {
-	case key == "client_token" && idempotencyTokenPlaceholderValue(value):
-		return true
-	case key == "retry_without_token" && numericStringPlaceholderValue(value):
-		return true
-	case tokenLikePlaceholderKey(key):
-		return tokenLikePlaceholderValue(value)
-	default:
-		return false
-	}
-}
-
-func tokenLikePlaceholderKey(key string) bool {
-	return key == "token" ||
-		strings.HasSuffix(key, "_token") ||
-		strings.HasSuffix(key, "-token")
-}
-
-func tokenLikePlaceholderValue(value string) bool {
-	normalized := strings.ToLower(strings.Trim(value, `"'`))
-	if normalized == "" || credentialShapedIdentifier(normalized) {
-		return false
-	}
-	return resourceTokenPlaceholderValue(value) ||
-		isPlaceholderValue(value) ||
-		normalized == "token" ||
-		strings.Contains(normalized, "...") ||
-		strings.Contains(normalized, "xxx") ||
-		strings.Contains(normalized, "_or_") ||
-		strings.HasSuffix(normalized, "_token") ||
-		strings.HasPrefix(normalized, ".")
-}
-
-func idempotencyTokenPlaceholderValue(value string) bool {
-	return numericStringPlaceholderValue(value) || uuidStringPlaceholderValue(value)
-}
-
-func uuidStringPlaceholderValue(value string) bool {
-	normalized := strings.Trim(value, `"'`)
-	parts := strings.Split(normalized, "-")
-	if len(parts) != 5 {
-		return false
-	}
-	for i, part := range parts {
-		want := []int{8, 4, 4, 4, 12}[i]
-		if len(part) != want {
-			return false
-		}
-		for _, r := range part {
-			if (r >= '0' && r <= '9') ||
-				(r >= 'a' && r <= 'f') ||
-				(r >= 'A' && r <= 'F') {
-				continue
-			}
-			return false
-		}
-	}
-	return true
-}
-
-func numericStringPlaceholderValue(value string) bool {
-	normalized := strings.Trim(value, `"'`)
-	if normalized == "" {
-		return false
-	}
-	for _, r := range normalized {
-		if r < '0' || r > '9' {
-			return false
-		}
-	}
-	return true
-}
-
-func isBenignCodeCredentialExpression(file, value string) bool {
-	normalized := strings.TrimSpace(value)
-	if strings.HasPrefix(normalized, "regexp.MustCompile(") {
-		return true
-	}
-	if !sourceCodeFile(file) || quotedLiteral(value) || credentialShapedValue(value) {
-		return false
-	}
-	return codeReferenceExpression(normalized)
-}
-
-func sourceCodeFile(file string) bool {
-	switch filepath.Ext(file) {
-	case ".go", ".py":
-		return true
-	default:
-		return false
-	}
-}
-
-func quotedLiteral(value string) bool {
-	normalized := strings.TrimSpace(value)
-	return len(normalized) >= 2 &&
-		((strings.HasPrefix(normalized, `"`) && strings.HasSuffix(normalized, `"`)) ||
-			(strings.HasPrefix(normalized, `'`) && strings.HasSuffix(normalized, `'`)))
-}
-
-func codeReferenceExpression(value string) bool {
-	if value == "" {
-		return false
-	}
-	for _, marker := range []string{".", "(", ")", "[", "]", "{"} {
-		if strings.Contains(value, marker) {
-			return true
-		}
-	}
-	return codeIdentifier(value) && !credentialNameFragment(value)
-}
-
-func codeIdentifier(value string) bool {
-	for i, r := range value {
-		switch {
-		case r >= 'a' && r <= 'z':
-		case r >= 'A' && r <= 'Z':
-		case r == '_' && i > 0:
-		case r >= '0' && r <= '9' && i > 0:
-		default:
-			return false
-		}
-	}
-	return true
-}
-
-func credentialNameFragment(value string) bool {
-	normalized := strings.ToLower(value)
-	for _, marker := range []string{"secret", "token", "password", "passwd", "key"} {
-		if strings.Contains(normalized, marker) {
-			return true
-		}
-	}
-	return false
-}
-
-func isSchemaDottedIdentifier(line, match string) bool {
-	return strings.Contains(line, "schema ") && strings.Contains(match, "_")
-}
-
-func isNonSecretLiteralValue(value string) bool {
-	switch strings.ToLower(strings.TrimSpace(strings.Trim(value, `"'`))) {
-	case "true", "false", "null", "nil", "{", "[":
-		return true
-	default:
-		return false
-	}
-}
-
-func isWebhookCredentialKey(key string) bool {
-	return strings.Contains(strings.ReplaceAll(key, "_", ""), "webhook")
-}
-
-func webhookAssignmentValueLooksCredentialLike(value string) bool {
-	normalized := strings.ToLower(strings.Trim(value, `"'`))
-	if normalized == "" || isPlaceholderValue(normalized) || isNonSecretLiteralValue(normalized) {
-		return false
-	}
-	return urlRemainderLooksCredentialLike(removeAnglePlaceholders(normalized)) ||
-		credentialShapedIdentifier(strings.Trim(normalized, "$"))
-}
-
-func isExplicitCredentialKey(key string) bool {
-	compact := strings.ReplaceAll(key, "_", "")
-	switch compact {
-	case "token",
-		"accesstoken",
-		"refreshtoken",
-		"authtoken",
-		"bearertoken",
-		"sessiontoken",
-		"servicetoken",
-		"apikey",
-		"accesskey",
-		"privatekey",
-		"apisecret",
-		"secret",
-		"secretkey",
-		"clientsecret",
-		"password",
-		"passwd":
-		return true
-	}
-	for _, phrase := range []string{
-		"accesstoken",
-		"refreshtoken",
-		"authtoken",
-		"bearertoken",
-		"sessiontoken",
-		"servicetoken",
-		"bottoken",
-		"apikey",
-		"accesskey",
-		"privatekey",
-		"apisecret",
-		"clientsecret",
-		"secretkey",
-	} {
-		if strings.Contains(compact, phrase) {
-			return true
-		}
-	}
-	parts := credentialKeyParts(key)
-	for _, phrase := range [][2]string{
-		{"access", "token"},
-		{"refresh", "token"},
-		{"auth", "token"},
-		{"bearer", "token"},
-		{"session", "token"},
-		{"service", "token"},
-		{"bot", "token"},
-		{"api", "key"},
-		{"access", "key"},
-		{"private", "key"},
-		{"api", "secret"},
-		{"client", "secret"},
-		{"secret", "key"},
-	} {
-		if hasAdjacentCredentialParts(parts, phrase[0], phrase[1]) {
-			return true
-		}
-	}
-	for _, part := range parts {
-		switch part {
-		case "token", "secret", "password", "passwd":
-			return true
-		}
-	}
-	for _, suffix := range []string{
-		"token",
-		"accesstoken",
-		"refreshtoken",
-		"authtoken",
-		"bearertoken",
-		"sessiontoken",
-		"servicetoken",
-		"bottoken",
-		"apikey",
-		"accesskey",
-		"privatekey",
-		"apisecret",
-		"clientsecret",
-		"secret",
-		"secretkey",
-		"password",
-		"passwd",
-	} {
-		if strings.HasSuffix(compact, suffix) {
-			return true
-		}
-	}
-	for _, suffix := range []string{
-		"_access_token",
-		"_refresh_token",
-		"_auth_token",
-		"_bearer_token",
-		"_session_token",
-		"_service_token",
-		"_api_key",
-		"_access_key",
-		"_private_key",
-		"_api_secret",
-		"_client_secret",
-		"_secret",
-		"_secret_key",
-		"_password",
-		"_passwd",
-	} {
-		if strings.HasSuffix(key, suffix) {
-			return true
-		}
-	}
-	return false
-}
-
-func credentialKeyParts(key string) []string {
-	var parts []string
-	for _, part := range strings.Split(key, "_") {
-		if part != "" {
-			parts = append(parts, part)
-		}
-	}
-	return parts
-}
-
-func hasAdjacentCredentialParts(parts []string, first, second string) bool {
-	for i := 0; i+1 < len(parts); i++ {
-		if parts[i] == first && parts[i+1] == second {
-			return true
-		}
-	}
-	return false
-}
-
-func credentialAssignmentValue(match []string) string {
-	for _, value := range match[1:] {
-		if value != "" {
-			return value
-		}
-	}
-	return ""
-}
-
-func looksLikeEqualityComparison(value string) bool {
-	return strings.HasPrefix(strings.TrimSpace(value), "=")
-}
-
-func isPlaceholderCredentialURL(raw string) bool {
-	userInfo, ok := credentialURLUserInfo(raw)
-	if !ok {
-		return false
-	}
-	_, password, ok := strings.Cut(userInfo, ":")
-	if !ok {
-		return false
-	}
-	return credentialURLPasswordPlaceholder(password)
-}
-
-func credentialURLPasswordPlaceholder(password string) bool {
-	normalized := strings.ToLower(password)
-	decoded := strings.ReplaceAll(normalized, "%3c", "<")
-	decoded = strings.ReplaceAll(decoded, "%3e", ">")
-	switch decoded {
-	case "placeholder", "redacted", "<redacted>", "xxxx":
-		return true
-	}
-	return angleWrappedPlaceholder(decoded) || percentWrappedPlaceholder(decoded)
-}
-
-func credentialURLUserInfo(raw string) (string, bool) {
-	schemeIdx := strings.Index(raw, "://")
-	if schemeIdx < 0 {
-		return "", false
-	}
-	rest := raw[schemeIdx+len("://"):]
-	atIdx := strings.Index(rest, "@")
-	if atIdx < 0 {
-		return "", false
-	}
-	return rest[:atIdx], true
-}
-
-func newFinding(rule, file string, line int, source, excerpt string) Finding {
-	return Finding{
-		Rule:       rule,
-		Action:     actionForRule(rule),
-		File:       file,
-		Line:       line,
-		Source:     source,
-		Excerpt:    excerpt,
-		Message:    messageForRule(rule),
-		Suggestion: suggestionForRule(rule),
-	}
-}
-
-func messageForRule(rule string) string {
-	switch rule {
-	case "public_content_generic_credential":
-		return "public contribution contains a generic credential assignment"
-	case "public_content_private_key_block":
-		return "public contribution contains a private key block"
-	case "public_content_jwt_like_token":
-		return "public contribution contains a JWT-like token"
-	case "public_content_bearer_header":
-		return "public contribution contains an Authorization bearer token"
-	case "public_content_credential_url":
-		return "public contribution contains credentials embedded in a URL"
-	case "public_content_private_ipv4":
-		return "public contribution contains a private-network IP address"
-	case "public_content_automation_branch":
-		return "public contribution uses an automation-shaped branch name"
-	case "public_content_change_id_trailer":
-		return "public contribution contains a Change-Id trailer"
-	case "public_content_reviewed_on_trailer":
-		return "public contribution contains a Reviewed-on trailer"
-	case "public_content_provenance_marker":
-		return "public contribution contains a prohibited provenance marker"
-	case "public_content_detector_fingerprint":
-		return "public rule/config content exposes public detector fingerprints"
-	case "public_content_harness_metadata":
-		return "public contribution contains visible harness pipeline metadata"
-	case "public_content_ccm_harness_trailer":
-		return "public contribution contains a CCM-Harness trailer"
-	case "public_content_semantic_candidate":
-		return "public contribution contains text for semantic public content review"
-	default:
-		return "public contribution contains content that should not be published"
-	}
-}
-
-func suggestionForRule(rule string) string {
-	switch actionForRule(rule) {
-	case "REJECT":
-		return "remove the value from the public contribution and replace it with a non-sensitive placeholder"
-	default:
-		return "remove private workflow metadata before publishing the public contribution"
-	}
-}
-
-func redactAssignment(match string) string {
-	key, ok := credentialAssignmentKey(match)
-	if !ok {
-		return "<credential-assignment>"
-	}
-	return fmt.Sprintf("%s= <redacted>", strings.TrimSpace(key))
-}
-
-func credentialAssignmentKey(match string) (string, bool) {
-	idx := -1
-	for _, sep := range []string{":", "="} {
-		if candidate := strings.Index(match, sep); candidate >= 0 && (idx < 0 || candidate < idx) {
-			idx = candidate
-		}
-	}
-	if idx < 0 {
-		return "", false
-	}
-	return match[:idx], true
-}
-
-func redactToken(_ string) string {
-	return "<jwt-like-token>"
-}
-
-func redactedSemanticExcerpt(text string) string {
-	normalized := strings.Join(strings.Fields(text), " ")
-	if normalized == "" {
-		return ""
-	}
-	signals := semanticSignals(normalized)
-	if len(signals) == 0 {
-		return ""
-	}
-	sanitized := truncateRunes(sanitizeSemanticExcerpt(text), 600)
-	return fmt.Sprintf("semantic signals: %s; excerpt: %q", strings.Join(signals, ","), sanitized)
-}
-
-func semanticSignals(normalized string) []string {
-	lower := strings.ToLower(normalized)
-	var signals []string
-	add := func(signal string) {
-		for _, existing := range signals {
-			if existing == signal {
-				return
-			}
-		}
-		signals = append(signals, signal)
-	}
-
-	hasPrivateScope := strings.Contains(lower, "private") || strings.Contains(lower, "internal-only")
-	hasRequestMetadata := strings.Contains(lower, "request header") || strings.Contains(lower, "request headers") || strings.Contains(lower, "authorization header") || strings.Contains(lower, "metadata header")
-	hasTrustBoundary := strings.Contains(lower, "spoof") || strings.Contains(lower, "trust") || strings.Contains(lower, "risk scoring") || strings.Contains(lower, "classification")
-	hasRoadmap := strings.Contains(lower, "roadmap") || strings.Contains(lower, "migration") || strings.Contains(lower, "rollout") || strings.Contains(lower, "cutover") || strings.Contains(lower, "unpublished")
-	hasTiming := strings.Contains(lower, "target date") || strings.Contains(lower, "friday") || strings.Contains(lower, "monday") || strings.Contains(lower, "tuesday") || strings.Contains(lower, "wednesday") || strings.Contains(lower, "thursday") || strings.Contains(lower, "customer-visible")
-	hasImplementation := strings.Contains(lower, "server-side") || strings.Contains(lower, "implementation")
-
-	if hasPrivateScope && hasRequestMetadata && hasTrustBoundary {
-		add("private_scope")
-		add("request_metadata")
-		add("trust_boundary_detail")
-	}
-	if hasRoadmap && (hasPrivateScope || hasTiming) {
-		add("roadmap_detail")
-		if hasPrivateScope {
-			add("private_scope")
-		}
-		if hasTiming {
-			add("roadmap_timing")
-		}
-	}
-	if hasPrivateScope && hasImplementation && hasTrustBoundary {
-		add("private_scope")
-		add("implementation_detail")
-		add("trust_boundary_detail")
-	}
-
-	return signals
-}
-
-func sanitizeSemanticExcerpt(text string) string {
-	text = redactPrivateKeyBlocks(text)
-	text = credentialAssignmentRE.ReplaceAllStringFunc(text, sanitizeCredentialAssignment)
-	text = strings.ReplaceAll(text, `<redacted>"`, `<redacted>`)
-	text = strings.ReplaceAll(text, `<redacted>'`, `<redacted>`)
-	text = semanticBearerHeaderRE.ReplaceAllString(text, "Authorization: Bearer <redacted>")
-	text = jwtLikeRE.ReplaceAllString(text, "<jwt-like-token>")
-	text = credentialURLRE.ReplaceAllStringFunc(text, sanitizeCredentialURL)
-	return strings.Join(strings.Fields(text), " ")
-}
-
-func redactPrivateKeyBlocks(text string) string {
-	lines := strings.Split(text, "\n")
-	var out []string
-	inPrivateKey := false
-	for _, line := range lines {
-		if strings.Contains(line, privateKeyBeginPrefix) && strings.Contains(line, privateKeyMarker) {
-			out = append(out, "<private-key-block>")
-			inPrivateKey = true
-			if strings.Contains(line, privateKeyEndPrefix) && strings.Contains(line, privateKeyMarker) {
-				inPrivateKey = false
-			}
-			continue
-		}
-		if inPrivateKey {
-			if strings.Contains(line, privateKeyEndPrefix) && strings.Contains(line, privateKeyMarker) {
-				inPrivateKey = false
-			}
-			continue
-		}
-		out = append(out, line)
-	}
-	return strings.Join(out, "\n")
-}
-
-func sanitizeCredentialAssignment(match string) string {
-	key, ok := credentialAssignmentKey(match)
-	if !ok {
-		return "<credential-assignment>"
-	}
-	return strings.TrimSpace(key) + "=<redacted>"
-}
-
-func sanitizeCredentialURL(raw string) string {
-	redacted := redactCredentialURL(raw)
-	redacted = strings.ReplaceAll(redacted, "%3Cuser%3E", "<user>")
-	redacted = strings.ReplaceAll(redacted, "%3Credacted%3E", "<redacted>")
-	return redacted
-}
-
-func truncateRunes(text string, limit int) string {
-	if limit <= 0 {
-		return ""
-	}
-	runes := []rune(text)
-	if len(runes) <= limit {
-		return text
-	}
-	return string(runes[:limit]) + "..."
-}

internal/qualitygate/publiccontent/types.go

@@ -1,30 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package publiccontent
-
-import "github.com/larksuite/cli/internal/qualitygate/report"
-
-type Options struct {
-	Repo         string
-	ChangedFrom  string
-	MetadataPath string
-	BranchName   string
-}
-
-type Metadata struct {
-	Title  string `json:"title"`
-	Body   string `json:"body"`
-	Branch string `json:"branch"`
-}
-
-type Finding struct {
-	Rule       string
-	Action     report.Action
-	File       string
-	Line       int
-	Source     string
-	Excerpt    string
-	Message    string
-	Suggestion string
-}

internal/qualitygate/rules/dryrun.go

@@ -174,9 +174,8 @@ type materializedExample struct {
 }
 
 type placeholderContext struct {
-	FlagName    string
-	FlagUsage   string
-	FlagDefault string
+	FlagName  string
+	FlagUsage string
 }
 
 func materializePlaceholderExample(raw string, cmd manifest.Command) (materializedExample, bool) {
@@ -248,7 +247,6 @@ func placeholderContextForFlag(name string, flag *manifest.Flag) placeholderCont
 	ctx := placeholderContext{FlagName: name}
 	if flag != nil {
 		ctx.FlagUsage = flag.Usage
-		ctx.FlagDefault = flag.DefValue
 	}
 	return ctx
 }
@@ -311,17 +309,11 @@ func fakeValueForPlaceholder(raw string, ctx placeholderContext) (string, bool)
 	if name == "" {
 		return "", false
 	}
-	if value, ok := fakeNumericValueForPlaceholder(name, ctx); ok {
-		return value, true
-	}
-	if value, ok := fakeContextualURLValueForPlaceholder(name, ctx); ok {
-		return value, true
-	}
 	if value, ok := fakeValueFromPlaceholderName(name); ok {
 		return value, true
 	}
 	if isGenericPlaceholderName(name) {
-		return fakeValueFromContextHint(ctx)
+		return fakeValueFromUsageHint(ctx.FlagUsage)
 	}
 	return "", false
 }
@@ -344,26 +336,16 @@ func fakeValueFromPlaceholderName(name string) (string, bool) {
 		return "file_test123", true
 	case hasPlaceholderToken(tokens, "file") && hasPlaceholderToken(tokens, "token"):
 		return "file_test123", true
-	case hasPlaceholderToken(tokens, "folder") && hasPlaceholderToken(tokens, "token"):
-		return "fld_test123", true
 	case hasPlaceholderToken(tokens, "image", "img"):
 		return "img_test123", true
 	case hasPlaceholderToken(tokens, "app"):
 		return "app_test123", true
-	case hasPlaceholderToken(tokens, "draft"):
-		return "draft_test123", true
-	case hasPlaceholderToken(tokens, "label"):
-		return "label_test123", true
-	case hasPlaceholderToken(tokens, "share"):
-		return "share_test123", true
 	case hasPlaceholderToken(tokens, "doc", "document"):
 		return "doc_test123", true
 	case hasPlaceholderToken(tokens, "sheet", "spreadsheet"):
 		return "shtcn_test123", true
 	case hasPlaceholderToken(tokens, "base"):
 		return "base_test123", true
-	case hasPlaceholderToken(tokens, "space"):
-		return "space_test123", true
 	case hasPlaceholderToken(tokens, "table"):
 		return "tbl_test123", true
 	case hasPlaceholderToken(tokens, "view"):
@@ -395,98 +377,17 @@ func fakeValueFromPlaceholderName(name string) (string, bool) {
 	}
 }
 
-func fakeValueFromContextHint(ctx placeholderContext) (string, bool) {
-	if value, ok := fakeNumericValueForPlaceholder("", ctx); ok {
-		return value, true
-	}
-	if value, ok := fakeContextualURLValueForPlaceholder("", ctx); ok {
-		return value, true
-	}
-	match := placeholderValuePattern.FindStringSubmatch(strings.ToLower(ctx.FlagUsage))
+func fakeValueFromUsageHint(usage string) (string, bool) {
+	match := placeholderValuePattern.FindStringSubmatch(strings.ToLower(usage))
 	if len(match) != 2 || !knownTokenPrefix(match[1]) {
 		return "", false
 	}
 	return match[1] + "_test123", true
 }
 
-func fakeContextualURLValueForPlaceholder(name string, ctx placeholderContext) (string, bool) {
-	nameTokens := placeholderTokenSet(name)
-	flagName := strings.ReplaceAll(strings.ToLower(ctx.FlagName), "-", "_")
-	flagTokens := placeholderTokenSet(flagName)
-	if !hasPlaceholderToken(nameTokens, "url", "link") && !hasPlaceholderToken(flagTokens, "url", "link") {
-		return "", false
-	}
-	usage := strings.ToLower(ctx.FlagUsage)
-	if strings.Contains(usage, "lark") || strings.Contains(usage, "feishu") || strings.Contains(usage, "document url") {
-		return "https://example.feishu.cn/docx/doc_test123", true
-	}
-	return "", false
-}
-
-func fakeNumericValueForPlaceholder(name string, ctx placeholderContext) (string, bool) {
-	nameTokens := placeholderTokenSet(name)
-	flagName := strings.ReplaceAll(strings.ToLower(ctx.FlagName), "-", "_")
-	flagTokens := placeholderTokenSet(flagName)
-	usage := strings.ToLower(ctx.FlagUsage)
-
-	switch {
-	case placeholderTokenPair(nameTokens, "meeting", "id") || placeholderTokenPair(flagTokens, "meeting", "id"):
-		return "400000000001", true
-	case placeholderTokenPair(nameTokens, "meeting", "ids") || placeholderTokenPair(flagTokens, "meeting", "ids"):
-		return "400000000001", true
-	case placeholderTokenPair(nameTokens, "meeting", "no") || placeholderTokenPair(flagTokens, "meeting", "no"):
-		return "123456789", true
-	case placeholderTokenPair(nameTokens, "meeting", "number") || placeholderTokenPair(flagTokens, "meeting", "number"):
-		return "123456789", true
-	case hasPlaceholderToken(nameTokens, "timestamp") || hasPlaceholderToken(flagTokens, "timestamp") || strings.Contains(usage, "unix timestamp"):
-		return defaultPositiveInteger(ctx.FlagDefault, "1893456000"), true
-	case placeholderTokenPair(nameTokens, "page", "size") || placeholderTokenPair(flagTokens, "page", "size"):
-		return defaultPositiveInteger(ctx.FlagDefault, "20"), true
-	case placeholderTokenPair(nameTokens, "page", "limit") || placeholderTokenPair(flagTokens, "page", "limit"):
-		return defaultPositiveInteger(ctx.FlagDefault, "10"), true
-	case numericPlaceholderName(nameTokens) || numericPlaceholderName(flagTokens) || numericUsageHint(usage):
-		return defaultPositiveInteger(ctx.FlagDefault, "20"), true
-	default:
-		return "", false
-	}
-}
-
-func numericPlaceholderName(tokens map[string]bool) bool {
-	if len(tokens) == 0 || hasPlaceholderToken(tokens, "token", "format", "type", "status", "mode") {
-		return false
-	}
-	return hasPlaceholderToken(tokens,
-		"amount", "count", "depth", "height", "index", "length", "limit", "max",
-		"number", "revision", "size", "width",
-	)
-}
-
-func numericUsageHint(usage string) bool {
-	if usage == "" {
-		return false
-	}
-	return strings.Contains(usage, "positive integer") ||
-		strings.Contains(usage, "decimal integer") ||
-		strings.Contains(usage, "number of ") ||
-		strings.Contains(usage, "(number)")
-}
-
-func defaultPositiveInteger(raw, fallback string) string {
-	raw = strings.TrimSpace(raw)
-	if raw == "" || strings.HasPrefix(raw, "-") || raw == "0" {
-		return fallback
-	}
-	for _, r := range raw {
-		if r < '0' || r > '9' {
-			return fallback
-		}
-	}
-	return raw
-}
-
 func knownTokenPrefix(prefix string) bool {
 	switch prefix {
-	case "app", "base", "doc", "draft", "file", "fld", "img", "item", "label", "meeting", "obcn", "oc", "od", "om", "ou", "page", "rec", "share", "shtcn", "space", "task", "tbl", "token", "viw", "wiki":
+	case "app", "base", "doc", "file", "fld", "img", "item", "meeting", "obcn", "oc", "od", "om", "ou", "page", "rec", "shtcn", "task", "tbl", "token", "viw", "wiki":
 		return true
 	default:
 		return false
@@ -530,10 +431,6 @@ func hasPlaceholderToken(tokens map[string]bool, wants ...string) bool {
 	return false
 }
 
-func placeholderTokenPair(tokens map[string]bool, first, second string) bool {
-	return tokens[first] && tokens[second]
-}
-
 func hasUnresolvedDryRunPlaceholder(value string) bool {
 	if skillscan.HasPlaceholder(value) {
 		return true
@@ -726,7 +623,6 @@ func appendDryRunArg(raw string) ([]string, error) {
 		return nil, fmt.Errorf("not a lark-cli command")
 	}
 	argv = truncateShellTail(argv)
-	argv = forceDryRunJSONFormat(argv)
 	hasDryRunArg := false
 	dryRunEnabled := false
 	for _, arg := range argv[1:] {
@@ -746,23 +642,6 @@ func appendDryRunArg(raw string) ([]string, error) {
 	return append(argv[1:], "--dry-run"), nil
 }
 
-func forceDryRunJSONFormat(argv []string) []string {
-	for i := 1; i < len(argv); i++ {
-		arg := argv[i]
-		if arg == "--format" {
-			if i+1 < len(argv) && argv[i+1] == "pretty" {
-				argv[i+1] = "json"
-			}
-			return argv
-		}
-		if arg == "--format=pretty" {
-			argv[i] = "--format=json"
-			return argv
-		}
-	}
-	return argv
-}
-
 func truncateShellTail(argv []string) []string {
 	for i, arg := range argv {
 		if i == 0 {

internal/qualitygate/rules/dryrun_test.go

@@ -305,161 +305,6 @@ func TestRunDryRunsMaterializesInlinePlaceholderFlagValues(t *testing.T) {
 	}
 }
 
-func TestRunDryRunsMaterializesNumericPlaceholderFlagValues(t *testing.T) {
-	cliBin, argsPath := fakeDryRunCLI(t, `{"api":[{"method":"GET","url":"/open-apis/vc/v1/bots/events","params":{"meeting_id":"400000000001","page_size":50}}]}`)
-	m := manifest.Manifest{Commands: []manifest.Command{{
-		Path:     "vc +meeting-events",
-		Runnable: true,
-		Flags: []manifest.Flag{
-			{Name: "meeting-id", TakesValue: true, Usage: "meeting ID to query; must be a long positive integer, not a 9-digit meeting number"},
-			{Name: "page-size", TakesValue: true, Usage: "page size, 20-100 (default 50)", DefValue: "50"},
-			{Name: "dry-run"},
-		},
-	}}}
-	ex := skillscan.Example{
-		Raw:            "lark-cli vc +meeting-events --meeting-id <meeting_id> --page-size <page_size>",
-		SourceFile:     "skills/lark-vc-agent/SKILL.md",
-		Line:           120,
-		HasPlaceholder: true,
-	}
-
-	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("numeric placeholder example should be executable after materialization: %#v", facts)
-	}
-	wantArgs := []string{"vc", "+meeting-events", "--meeting-id", "400000000001", "--page-size", "50", "--dry-run"}
-	if gotArgs := readArgs(t, argsPath); !reflect.DeepEqual(gotArgs, wantArgs) {
-		t.Fatalf("fake CLI args = %#v, want %#v", gotArgs, wantArgs)
-	}
-}
-
-func TestRunDryRunsMaterializesNumericPlaceholdersInsideJSONFlags(t *testing.T) {
-	cliBin, argsPath := fakeDryRunCLI(t, `{"api":[{"method":"GET","url":"/open-apis/test","params":{"timestamp":"1893456000","count":"20"}}]}`)
-	m := manifest.Manifest{Commands: []manifest.Command{{
-		Path:     "api GET",
-		Runnable: true,
-		Flags: []manifest.Flag{
-			{Name: "params", TakesValue: true},
-			{Name: "dry-run"},
-		},
-	}}}
-	ex := skillscan.Example{
-		Raw:            `lark-cli api GET /open-apis/test --params '{"timestamp":"<timestamp>","count":"<count>"}'`,
-		SourceFile:     "skills/lark-demo/SKILL.md",
-		Line:           20,
-		HasPlaceholder: true,
-	}
-
-	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("JSON numeric placeholder example should be executable after materialization: %#v", facts)
-	}
-	wantArgs := []string{"api", "GET", "/open-apis/test", "--params", `{"timestamp":"1893456000","count":"20"}`, "--dry-run"}
-	if gotArgs := readArgs(t, argsPath); !reflect.DeepEqual(gotArgs, wantArgs) {
-		t.Fatalf("fake CLI args = %#v, want %#v", gotArgs, wantArgs)
-	}
-}
-
-func TestRunDryRunsMaterializesLarkDocumentURLPlaceholders(t *testing.T) {
-	cliBin, argsPath := fakeDryRunCLI(t, `{"api":[{"method":"GET","url":"/open-apis/drive/v1/metas/batch_query"}]}`)
-	m := manifest.Manifest{Commands: []manifest.Command{{
-		Path:     "drive +inspect",
-		Runnable: true,
-		Flags: []manifest.Flag{
-			{Name: "url", TakesValue: true, Usage: "Lark/Feishu document URL (docx, doc, sheet, bitable, wiki, file, folder, mindnote, slides)"},
-			{Name: "format", TakesValue: true},
-			{Name: "dry-run"},
-		},
-	}}}
-	ex := skillscan.Example{
-		Raw:            "lark-cli drive +inspect --url '<url>' --format json",
-		SourceFile:     "skills/lark-drive/references/lark-drive-workflow-permission-governance-commands.md",
-		Line:           15,
-		HasPlaceholder: true,
-	}
-
-	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("Lark URL placeholder example should be executable after materialization: %#v", facts)
-	}
-	wantArgs := []string{"drive", "+inspect", "--url", "https://example.feishu.cn/docx/doc_test123", "--format", "json", "--dry-run"}
-	if gotArgs := readArgs(t, argsPath); !reflect.DeepEqual(gotArgs, wantArgs) {
-		t.Fatalf("fake CLI args = %#v, want %#v", gotArgs, wantArgs)
-	}
-}
-
-func TestRunDryRunsMaterializesResourceIDPlaceholderFlagValues(t *testing.T) {
-	cliBin, argsPath := fakeDryRunCLI(t, `{"api":[{"method":"GET","url":"/open-apis/wiki/v2/spaces/space_test123/nodes"}]}`)
-	m := manifest.Manifest{Commands: []manifest.Command{{
-		Path:     "wiki +node-list",
-		Runnable: true,
-		Flags: []manifest.Flag{
-			{Name: "space-id", TakesValue: true, Usage: "wiki space ID"},
-			{Name: "page-token", TakesValue: true, Usage: "page token"},
-			{Name: "format", TakesValue: true},
-			{Name: "dry-run"},
-		},
-	}}}
-	ex := skillscan.Example{
-		Raw:            "lark-cli wiki +node-list --space-id <space_id> --page-token <PAGE_TOKEN> --format json",
-		SourceFile:     "skills/lark-wiki/references/lark-wiki-node-list.md",
-		Line:           24,
-		HasPlaceholder: true,
-	}
-
-	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("resource ID placeholder example should be executable after materialization: %#v", facts)
-	}
-	wantArgs := []string{"wiki", "+node-list", "--space-id", "space_test123", "--page-token", "page_test123", "--format", "json", "--dry-run"}
-	if gotArgs := readArgs(t, argsPath); !reflect.DeepEqual(gotArgs, wantArgs) {
-		t.Fatalf("fake CLI args = %#v, want %#v", gotArgs, wantArgs)
-	}
-}
-
-func TestRunDryRunsMaterializesResourcePlaceholdersInsideJSONFlags(t *testing.T) {
-	cliBin, argsPath := fakeDryRunCLI(t, `{"api":[{"method":"POST","url":"/open-apis/mail/v1/user_mailboxes/me/drafts/draft_test123/send"}]}`)
-	m := manifest.Manifest{Commands: []manifest.Command{{
-		Path:     "mail user_mailbox.drafts send",
-		Runnable: true,
-		Flags: []manifest.Flag{
-			{Name: "params", TakesValue: true},
-			{Name: "data", TakesValue: true},
-			{Name: "dry-run"},
-		},
-	}}}
-	ex := skillscan.Example{
-		Raw:            `lark-cli mail user_mailbox.drafts send --params '{"user_mailbox_id":"me","draft_id":"<draft_id>"}' --data '{"send_time":"<unix_timestamp>"}'`,
-		SourceFile:     "skills/lark-mail/references/lark-mail-send.md",
-		Line:           172,
-		HasPlaceholder: true,
-	}
-
-	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("JSON resource placeholder example should be executable after materialization: %#v", facts)
-	}
-	wantArgs := []string{"mail", "user_mailbox.drafts", "send", "--params", `{"user_mailbox_id":"me","draft_id":"draft_test123"}`, "--data", `{"send_time":"1893456000"}`, "--dry-run"}
-	if gotArgs := readArgs(t, argsPath); !reflect.DeepEqual(gotArgs, wantArgs) {
-		t.Fatalf("fake CLI args = %#v, want %#v", gotArgs, wantArgs)
-	}
-}
-
 func TestRunDryRunsSkipsUnknownFlagsBeforeDryRun(t *testing.T) {
 	m := manifest.Manifest{Commands: []manifest.Command{{
 		Path:     "im +chat-messages-list",
@@ -755,51 +600,6 @@ func TestAppendDryRunArgDoesNotDuplicate(t *testing.T) {
 	}
 }
 
-func TestAppendDryRunArgForcesJSONFormat(t *testing.T) {
-	got, err := appendDryRunArg("lark-cli vc +meeting-events --meeting-id 400000000001 --format pretty")
-	if err != nil {
-		t.Fatalf("appendDryRunArg() error = %v", err)
-	}
-	want := []string{"vc", "+meeting-events", "--meeting-id", "400000000001", "--format", "json", "--dry-run"}
-	if !reflect.DeepEqual(got, want) {
-		t.Fatalf("appendDryRunArg() = %#v, want %#v", got, want)
-	}
-}
-
-func TestAppendDryRunArgForcesInlineJSONFormat(t *testing.T) {
-	got, err := appendDryRunArg("lark-cli vc +meeting-events --meeting-id 400000000001 --format=pretty --dry-run")
-	if err != nil {
-		t.Fatalf("appendDryRunArg() error = %v", err)
-	}
-	want := []string{"vc", "+meeting-events", "--meeting-id", "400000000001", "--format=json", "--dry-run"}
-	if !reflect.DeepEqual(got, want) {
-		t.Fatalf("appendDryRunArg() = %#v, want %#v", got, want)
-	}
-}
-
-func TestAppendDryRunArgPreservesNonPrettyFormat(t *testing.T) {
-	for _, raw := range []string{
-		"lark-cli mail +watch --format data --dry-run",
-		"lark-cli export +events --format=ndjson --dry-run",
-		"lark-cli docs +fetch --format table",
-	} {
-		got, err := appendDryRunArg(raw)
-		if err != nil {
-			t.Fatalf("appendDryRunArg(%q) error = %v", raw, err)
-		}
-		for _, arg := range got {
-			if arg == "--format=json" {
-				t.Fatalf("appendDryRunArg(%q) unexpectedly rewrote inline format: %#v", raw, got)
-			}
-		}
-		for i, arg := range got {
-			if arg == "--format" && i+1 < len(got) && got[i+1] == "json" {
-				t.Fatalf("appendDryRunArg(%q) unexpectedly rewrote split format: %#v", raw, got)
-			}
-		}
-	}
-}
-
 func TestAppendDryRunArgForcesDryRunWhenExplicitlyDisabled(t *testing.T) {
 	got, err := appendDryRunArg("lark-cli docs +fetch --dry-run=false --doc abc")
 	if err != nil {

internal/qualitygate/rules/run.go

@@ -15,20 +15,18 @@ import (
 	manifestexamples "github.com/larksuite/cli/internal/qualitygate/examples"
 	"github.com/larksuite/cli/internal/qualitygate/facts"
 	"github.com/larksuite/cli/internal/qualitygate/manifest"
-	"github.com/larksuite/cli/internal/qualitygate/publiccontent"
 	"github.com/larksuite/cli/internal/qualitygate/report"
 	"github.com/larksuite/cli/internal/qualitygate/skillscan"
 	"github.com/larksuite/cli/internal/vfs"
 )
 
 type Options struct {
-	Repo                      string
-	CLIBin                    string
-	ChangedFrom               string
-	FactsOut                  string
-	ManifestPath              string
-	CommandIndexPath          string
-	PublicContentMetadataPath string
+	Repo             string
+	CLIBin           string
+	ChangedFrom      string
+	FactsOut         string
+	ManifestPath     string
+	CommandIndexPath string
 }
 
 func Run(ctx context.Context, opts Options) ([]report.Diagnostic, facts.Facts, error) {
@@ -100,60 +98,9 @@ func Run(ctx context.Context, opts Options) ([]report.Diagnostic, facts.Facts, e
 	if opts.ChangedFrom != "" {
 		diags = append(diags, errorDiags...)
 	}
-	publicContent, err := publiccontent.Collect(ctx, publiccontent.Options{
-		Repo:         opts.Repo,
-		ChangedFrom:  opts.ChangedFrom,
-		MetadataPath: opts.PublicContentMetadataPath,
-	})
-	if err != nil {
-		return nil, facts.Facts{}, err
-	}
-	diags = append(diags, publicContentDiagnostics(publicContent)...)
 	diags = filterPRDiagnostics(opts.Repo, opts.ChangedFrom, scope, m, diags)
 
-	builtFacts := facts.BuildWithCommandLookup(m, commandIndex, skillFacts, skillQualityFacts, errorFacts, exampleFacts, outputFacts, diags, scope.Files)
-	return diags, facts.WithPublicContent(builtFacts, publicContentFacts(publicContent)), nil
-}
-
-func publicContentDiagnostics(items []publiccontent.Finding) []report.Diagnostic {
-	if len(items) == 0 {
-		return nil
-	}
-	out := make([]report.Diagnostic, 0, len(items))
-	for _, item := range items {
-		if item.Rule == "public_content_semantic_candidate" {
-			continue
-		}
-		out = append(out, report.Diagnostic{
-			Rule:       item.Rule,
-			Action:     item.Action,
-			File:       item.File,
-			Line:       item.Line,
-			Message:    item.Message,
-			Suggestion: item.Suggestion,
-		})
-	}
-	return out
-}
-
-func publicContentFacts(items []publiccontent.Finding) []facts.PublicContentFact {
-	if len(items) == 0 {
-		return nil
-	}
-	out := make([]facts.PublicContentFact, 0, len(items))
-	for _, item := range items {
-		out = append(out, facts.PublicContentFact{
-			Rule:       item.Rule,
-			Action:     item.Action,
-			File:       item.File,
-			Line:       item.Line,
-			Source:     item.Source,
-			Excerpt:    item.Excerpt,
-			Message:    item.Message,
-			Suggestion: item.Suggestion,
-		})
-	}
-	return out
+	return diags, facts.BuildWithCommandLookup(m, commandIndex, skillFacts, skillQualityFacts, errorFacts, exampleFacts, outputFacts, diags, scope.Files), nil
 }
 
 func readManifestInput(path, kind, flag string) (manifest.Manifest, error) {
@@ -220,9 +167,6 @@ func filterPRDiagnostics(repo, changedFrom string, scope qdiff.Scope, m manifest
 }
 
 func prDiagnosticRelevant(repo string, changedFiles map[string]bool, commandScope diagnosticCommandScope, m manifest.Manifest, diag report.Diagnostic) bool {
-	if strings.HasPrefix(diag.Rule, "public_content_") {
-		return true
-	}
 	file := normalizeDiagnosticFile(repo, diag.File)
 	if file != "" && changedFiles[file] {
 		return true

internal/qualitygate/rules/run_test.go

@@ -189,99 +189,6 @@ description: Manage Drive comments with service command references.
 	}
 }
 
-func TestRunCollectsPublicContentFindingsIntoDiagnosticsAndFacts(t *testing.T) {
-	repo := t.TempDir()
-	runGit(t, repo, "init")
-	runGit(t, repo, "config", "user.email", "test@example.com")
-	runGit(t, repo, "config", "user.name", "Test User")
-	if err := vfs.WriteFile(filepath.Join(repo, "README.md"), []byte("# test\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	runGit(t, repo, "add", "README.md")
-	runGit(t, repo, "commit", "-m", "base")
-
-	if err := vfs.MkdirAll(filepath.Join(repo, "docs"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	publicDoc := "api_" + "key = \"example-public-key\"\n" +
-		"Public docs describe a pri" + "vate request header and trust classification detail.\n"
-	if err := vfs.WriteFile(filepath.Join(repo, "docs", "public.md"), []byte(publicDoc), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	runGit(t, repo, "add", "docs/public.md")
-	runGit(t, repo, "commit", "-m", "add public doc")
-
-	metadataPath := filepath.Join(repo, "pr-metadata.json")
-	if err := vfs.WriteFile(metadataPath, []byte(`{"title":"public docs","body":"Change`+`-Id: I0123456789abcdef0123456789abcdef01234567"}`), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	manifestPath := filepath.Join(repo, "command-manifest.json")
-	indexPath := filepath.Join(repo, "command-index.json")
-	m := manifest.Manifest{SchemaVersion: 1, Commands: []manifest.Command{{
-		Path:          "docs +fetch",
-		CanonicalPath: "docs +fetch",
-		Domain:        "docs",
-		Source:        manifest.SourceShortcut,
-	}}}
-	if err := manifest.WriteFile(manifestPath, manifest.KindCommandManifest, m); err != nil {
-		t.Fatal(err)
-	}
-	idx := manifest.Manifest{SchemaVersion: 1, Commands: append([]manifest.Command{}, m.Commands...)}
-	idx.Commands = append(idx.Commands, manifest.Command{
-		Path:          "drive files get",
-		CanonicalPath: "drive files get",
-		Domain:        "drive",
-		Source:        manifest.SourceService,
-		Generated:     true,
-		Runnable:      true,
-	})
-	if err := manifest.WriteFile(indexPath, manifest.KindCommandIndex, idx); err != nil {
-		t.Fatal(err)
-	}
-
-	diags, gotFacts, err := Run(context.Background(), Options{
-		Repo:                      repo,
-		CLIBin:                    "./lark-cli",
-		ChangedFrom:               "HEAD~1",
-		ManifestPath:              manifestPath,
-		CommandIndexPath:          indexPath,
-		PublicContentMetadataPath: metadataPath,
-	})
-	if err != nil {
-		t.Fatalf("Run() error = %v", err)
-	}
-	actions := map[string]report.Action{}
-	for _, diag := range diags {
-		actions[diag.Rule] = diag.Action
-	}
-	if actions["public_content_generic_credential"] != report.ActionReject {
-		t.Fatalf("generic credential diagnostic action = %q, diagnostics=%#v", actions["public_content_generic_credential"], diags)
-	}
-	if actions["public_content_change_id_trailer"] != report.ActionReject {
-		t.Fatalf("change-id diagnostic action = %q, diagnostics=%#v", actions["public_content_change_id_trailer"], diags)
-	}
-	if actions["public_content_semantic_candidate"] != "" {
-		t.Fatalf("semantic candidates should not become deterministic diagnostics: %#v", diags)
-	}
-	factRules := map[string]bool{}
-	for _, item := range gotFacts.PublicContent {
-		factRules[item.Rule] = true
-	}
-	for _, want := range []string{
-		"public_content_generic_credential",
-		"public_content_change_id_trailer",
-		"public_content_semantic_candidate",
-	} {
-		if !factRules[want] {
-			t.Fatalf("missing public content fact %s: %#v", want, gotFacts.PublicContent)
-		}
-	}
-	if len(gotFacts.PublicContent) < 3 {
-		t.Fatalf("public content facts = %#v", gotFacts.PublicContent)
-	}
-}
-
 func TestLoadBaseReferenceManifestReadsCommandGolden(t *testing.T) {
 	repo := t.TempDir()
 	runGit(t, repo, "init")
@@ -599,7 +506,7 @@ func TestNormalizeDiagnosticFileHandlesAbsoluteRepo(t *testing.T) {
 
 func runGit(t *testing.T, repo string, args ...string) {
 	t.Helper()
-	cmd := exec.Command("git", append([]string{"-c", "core.hooksPath=/dev/null", "-C", repo}, args...)...)
+	cmd := exec.Command("git", append([]string{"-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/qualitygate/semantic/client.go

@@ -339,7 +339,7 @@ func jsonSchemaResponseFormat() map[string]any {
 							"properties": map[string]any{
 								"category": map[string]any{
 									"type": "string",
-									"enum": []string{"error_hint", "default_output", "naming", "skill_quality", "public_content_leakage"},
+									"enum": []string{"error_hint", "default_output", "naming", "skill_quality"},
 								},
 								"severity": map[string]any{
 									"type": "string",

internal/qualitygate/semantic/gatekeeper.go

@@ -10,10 +10,9 @@ import (
 	"strings"
 
 	"github.com/larksuite/cli/internal/qualitygate/facts"
-	"github.com/larksuite/cli/internal/qualitygate/report"
 )
 
-var evidencePattern = regexp.MustCompile(`^facts\.(commands|skills|errors|outputs|public_content)\[(\d+)\]$`)
+var evidencePattern = regexp.MustCompile(`^facts\.(commands|skills|errors|outputs)\[(\d+)\]$`)
 
 func Decide(f facts.Facts, r Review, p Policy) Decision {
 	return DecideWithWaivers(f, r, p, Waivers{})
@@ -173,16 +172,6 @@ func evidenceFingerprint(f facts.Facts, ev string) string {
 			"has_default_limit:" + strconv.FormatBool(out.HasDefaultLimit),
 			"has_decision_field:" + strconv.FormatBool(out.HasDecisionField),
 		}, ":")
-	case "public_content":
-		item := f.PublicContent[idx]
-		return strings.Join([]string{
-			"public_content",
-			"rule:" + item.Rule,
-			"action:" + string(item.Action),
-			"file:" + item.File,
-			"line:" + strconv.Itoa(item.Line),
-			"source:" + item.Source,
-		}, ":")
 	default:
 		return "ref:" + ev
 	}
@@ -212,7 +201,7 @@ func validFinding(f Finding) bool {
 
 func allowedCategory(category string) bool {
 	switch category {
-	case "error_hint", "default_output", "naming", "skill_quality", "public_content_leakage":
+	case "error_hint", "default_output", "naming", "skill_quality":
 		return true
 	default:
 		return false
@@ -258,12 +247,6 @@ func reproducibleEvidence(f facts.Facts, category, kind string, idx int) bool {
 		}
 		skill := f.Skills[idx]
 		return skill.ReferencesInvalidCommand
-	case "public_content_leakage":
-		if kind != "public_content" {
-			return false
-		}
-		item := f.PublicContent[idx]
-		return item.Action == report.ActionReject || item.Rule == "public_content_semantic_candidate"
 	default:
 		return false
 	}
@@ -294,8 +277,6 @@ func evidenceExists(f facts.Facts, kind string, idx int) bool {
 		return idx < len(f.Errors)
 	case "outputs":
 		return idx < len(f.Outputs)
-	case "public_content":
-		return idx < len(f.PublicContent)
 	default:
 		return false
 	}

internal/qualitygate/semantic/gatekeeper_test.go

@@ -242,7 +242,6 @@ func TestGatekeeperBlockerMatrix(t *testing.T) {
 		Outputs:       []facts.OutputFact{{Command: "im messages list", IsList: true, HasDefaultLimit: false, HasDecisionField: false}},
 		Commands:      []facts.CommandFact{{Path: "docs fetch", NameConflictsExisting: true}},
 		Skills:        []facts.SkillFact{{SourceFile: "skills/lark-doc/SKILL.md", Line: 3, ReferencesInvalidCommand: true}},
-		PublicContent: []facts.PublicContentFact{{Rule: "public_content_generic_credential", Action: "REJECT", File: "docs/public.md", Line: 4, Source: "metadata"}},
 	}
 	for _, tc := range []struct {
 		category string
@@ -252,7 +251,6 @@ func TestGatekeeperBlockerMatrix(t *testing.T) {
 		{"default_output", "facts.outputs[0]"},
 		{"naming", "facts.commands[0]"},
 		{"skill_quality", "facts.skills[0]"},
-		{"public_content_leakage", "facts.public_content[0]"},
 	} {
 		t.Run(tc.category, func(t *testing.T) {
 			r := Review{Findings: []Finding{{
@@ -270,59 +268,6 @@ func TestGatekeeperBlockerMatrix(t *testing.T) {
 	}
 }
 
-func TestGatekeeperDoesNotPromotePublicContentWarningsToBlockers(t *testing.T) {
-	f := facts.Facts{
-		SchemaVersion: 1,
-		PublicContent: []facts.PublicContentFact{{
-			Rule:   "public_content_" + "pri" + "vate_ipv4",
-			Action: "WARNING",
-			File:   "docs/network.md",
-			Line:   1,
-			Source: "file",
-		}},
-	}
-	review := Review{Findings: []Finding{{
-		Category:        "public_content_leakage",
-		Severity:        "minor",
-		Evidence:        []string{"facts.public_content[0]"},
-		Message:         "pri" + "vate network address appears in public docs",
-		SuggestedAction: "confirm the public docs do not expose pri" + "vate deployment details",
-	}}}
-
-	got := Decide(f, review, DefaultPolicy())
-	if len(got.Blockers) != 0 || len(got.Warnings) != 1 {
-		t.Fatalf("public content warning should not become a blocker: %#v", got)
-	}
-	if got.Warnings[0].ReviewAction != ReviewActionObserve {
-		t.Fatalf("review action = %q, want %q", got.Warnings[0].ReviewAction, ReviewActionObserve)
-	}
-}
-
-func TestGatekeeperAllowsPublicContentSemanticCandidatesAsBlockers(t *testing.T) {
-	f := facts.Facts{
-		SchemaVersion: 1,
-		PublicContent: []facts.PublicContentFact{{
-			Rule:   "public_content_semantic_candidate",
-			Action: "WARNING",
-			File:   "docs/public.md",
-			Line:   1,
-			Source: "file",
-		}},
-	}
-	review := Review{Findings: []Finding{{
-		Category:        "public_content_leakage",
-		Severity:        "major",
-		Evidence:        []string{"facts.public_content[0]"},
-		Message:         "semantic review found pri" + "vate rollout detail",
-		SuggestedAction: "remove pri" + "vate rollout detail from public docs",
-	}}}
-
-	got := Decide(f, review, DefaultPolicy())
-	if len(got.Blockers) != 1 {
-		t.Fatalf("semantic candidate should remain blockable, got %#v", got)
-	}
-}
-
 func TestGatekeeperSkillQualityOnlyBlocksInvalidCommandReferences(t *testing.T) {
 	f := facts.Facts{
 		SchemaVersion: 1,

internal/qualitygate/semantic/prompt.go

@@ -24,7 +24,7 @@ func BuildPrompt(f facts.Facts) []Message {
 			"Use only the provided JSON view.",
 			"The changed_summary may summarize broad changed surfaces; review only listed facts, not omitted summarized items.",
 			"Use fact_ref values exactly when writing finding evidence.",
-			"Only facts.commands, facts.skills, facts.errors, facts.outputs, and facts.public_content fact_ref values may be blocker evidence.",
+			"Only facts.commands, facts.skills, facts.errors, and facts.outputs fact_ref values may be blocker evidence.",
 			"Evidence entries must be exact fact_ref strings such as \"facts.commands[0]\" with no explanations, labels, or suffix text.",
 			"facts.examples and facts.skill_quality entries are context only.",
 			"Report an error_hint finding for any facts.errors item where boundary is true, required_hint is true, and hint_action_count is 0.",
@@ -38,9 +38,6 @@ func BuildPrompt(f facts.Facts) []Message {
 			"For naming findings, use category \"naming\" and evidence containing that facts.commands fact_ref.",
 			"Report a skill_quality finding for any facts.skills item where references_invalid_command is true.",
 			"For skill_quality findings, use category \"skill_quality\" and evidence containing that facts.skills fact_ref.",
-			"Review public content leakage findings and semantic candidates without private dictionaries.",
-			"Do not reveal internal rule lists when explaining public content leakage.",
-			"For public_content_leakage findings, preserve the deterministic finding source and excerpt.",
 			"Report each distinct issue as a separate finding.",
 			"The verdict value must be \"pass\" when findings is empty and \"warn\" when findings is non-empty; never use \"fail\".",
 			"Severity must be one of \"minor\", \"major\", or \"critical\"; never use \"error\", \"warning\", \"medium\", or \"high\".",

internal/qualitygate/semantic/prompt_contract_test.go

@@ -23,10 +23,7 @@ func TestBuildPromptContainsSemanticReviewContract(t *testing.T) {
 		"A facts.outputs item with is_list true, has_default_limit false, and has_decision_field true must still produce a default_output finding.",
 		"Report a naming finding for any facts.commands item where name_conflicts_existing is true or flag_alias_conflict is true.",
 		"Report a skill_quality finding for any facts.skills item where references_invalid_command is true.",
-		"Review public content leakage findings and semantic candidates without private dictionaries.",
-		"Do not reveal internal rule lists when explaining public content leakage.",
-		"For public_content_leakage findings, preserve the deterministic finding source and excerpt.",
-		"Only facts.commands, facts.skills, facts.errors, facts.outputs, and facts.public_content fact_ref values may be blocker evidence.",
+		"Only facts.commands, facts.skills, facts.errors, and facts.outputs fact_ref values may be blocker evidence.",
 		"Evidence entries must be exact fact_ref strings such as \"facts.commands[0]\" with no explanations, labels, or suffix text.",
 		"facts.examples and facts.skill_quality entries are context only.",
 		"Report each distinct issue as a separate finding.",

internal/qualitygate/semantic/schema.go

@@ -78,11 +78,11 @@ func DefaultPolicy() Policy {
 	return Policy{
 		SchemaVersion:      1,
 		DefaultEnforcement: "observe",
-		BlockCategories:    []string{"error_hint", "default_output", "naming", "skill_quality", "public_content_leakage"},
+		BlockCategories:    []string{"error_hint", "default_output", "naming", "skill_quality"},
 		RolloutGroups: []RolloutGroup{{
 			ID:          "all",
 			Enforcement: "blocking",
-			Categories:  []string{"error_hint", "default_output", "naming", "skill_quality", "public_content_leakage"},
+			Categories:  []string{"error_hint", "default_output", "naming", "skill_quality"},
 			Owner:       "test",
 			Reason:      "default in-memory policy",
 		}},

internal/qualitygate/semantic/scope.go

@@ -82,15 +82,6 @@ func factScope(f facts.Facts, kind string, idx int) (FactScope, bool) {
 			Source:      item.Source,
 			CommandPath: item.Command,
 		}, true
-	case "public_content":
-		item := f.PublicContent[idx]
-		return FactScope{
-			FactKind:   "public_content",
-			Changed:    true,
-			Source:     item.Source,
-			SourceFile: item.File,
-			Line:       item.Line,
-		}, true
 	default:
 		return FactScope{}, false
 	}
@@ -204,7 +195,7 @@ func containsString(values []string, want string) bool {
 
 func allowedFactKind(kind string) bool {
 	switch kind {
-	case "skill", "command", "error", "output", "public_content":
+	case "skill", "command", "error", "output":
 		return true
 	default:
 		return false

internal/qualitygate/semantic/scope_test.go

@@ -81,30 +81,6 @@ func TestGatekeeperSkillQualityUsesSkillEvidence(t *testing.T) {
 	}
 }
 
-func TestGatekeeperUsesPublicContentEvidence(t *testing.T) {
-	f := facts.Facts{
-		SchemaVersion: 1,
-		PublicContent: []facts.PublicContentFact{{
-			Rule:   "public_content_generic_credential",
-			Action: "REJECT",
-			File:   "docs/public.md",
-			Line:   12,
-			Source: "metadata",
-		}},
-	}
-	review := Review{Findings: []Finding{{
-		Category:        "public_content_leakage",
-		Severity:        "critical",
-		Evidence:        []string{"facts.public_content[0]"},
-		Message:         "public content finding needs review",
-		SuggestedAction: "remove the sensitive public content",
-	}}}
-	got := Decide(f, review, DefaultPolicy())
-	if len(got.Blockers) != 1 || got.Blockers[0].RolloutGroups[0] != "all" {
-		t.Fatalf("expected public content blocker, got %#v", got)
-	}
-}
-
 func TestGatekeeperAppliesSharedWaiverID(t *testing.T) {
 	f := facts.Facts{
 		SchemaVersion: 1,

internal/qualitygate/semantic/view.go

@@ -13,29 +13,27 @@ import (
 )
 
 type InputView struct {
-	SchemaVersion        int                    `json:"schema_version"`
-	ChangedSummary       ChangedSummary         `json:"changed_summary"`
-	RuleSummary          []RuleSummaryItem      `json:"rule_summary,omitempty"`
-	Commands             []CommandInput         `json:"commands,omitempty"`
-	Skills               []SkillInput           `json:"skills,omitempty"`
-	SkillQuality         []SkillQualityInput    `json:"skill_quality,omitempty"`
-	Errors               []ErrorInput           `json:"errors,omitempty"`
-	Outputs              []OutputInput          `json:"outputs,omitempty"`
-	Examples             []ExampleInput         `json:"examples,omitempty"`
-	PublicContentLeakage []PublicContentInput   `json:"public_content_leakage,omitempty"`
-	Diagnostics          []facts.DiagnosticFact `json:"diagnostics,omitempty"`
+	SchemaVersion  int                    `json:"schema_version"`
+	ChangedSummary ChangedSummary         `json:"changed_summary"`
+	RuleSummary    []RuleSummaryItem      `json:"rule_summary,omitempty"`
+	Commands       []CommandInput         `json:"commands,omitempty"`
+	Skills         []SkillInput           `json:"skills,omitempty"`
+	SkillQuality   []SkillQualityInput    `json:"skill_quality,omitempty"`
+	Errors         []ErrorInput           `json:"errors,omitempty"`
+	Outputs        []OutputInput          `json:"outputs,omitempty"`
+	Examples       []ExampleInput         `json:"examples,omitempty"`
+	Diagnostics    []facts.DiagnosticFact `json:"diagnostics,omitempty"`
 }
 
 type ChangedSummary struct {
-	Commands      int      `json:"commands,omitempty"`
-	Skills        int      `json:"skills,omitempty"`
-	SkillQuality  int      `json:"skill_quality,omitempty"`
-	Errors        int      `json:"errors,omitempty"`
-	Outputs       int      `json:"outputs,omitempty"`
-	Examples      int      `json:"examples,omitempty"`
-	PublicContent int      `json:"public_content,omitempty"`
-	Domains       []string `json:"domains,omitempty"`
-	Sources       []string `json:"sources,omitempty"`
+	Commands     int      `json:"commands,omitempty"`
+	Skills       int      `json:"skills,omitempty"`
+	SkillQuality int      `json:"skill_quality,omitempty"`
+	Errors       int      `json:"errors,omitempty"`
+	Outputs      int      `json:"outputs,omitempty"`
+	Examples     int      `json:"examples,omitempty"`
+	Domains      []string `json:"domains,omitempty"`
+	Sources      []string `json:"sources,omitempty"`
 }
 
 type RuleSummaryItem struct {
@@ -88,22 +86,6 @@ type ExampleInput struct {
 	facts.CommandExample
 }
 
-type PublicContentInput struct {
-	FactRef string `json:"fact_ref"`
-	facts.PublicContentFact
-}
-
-func (v InputView) HasReviewableFacts() bool {
-	return len(v.Commands) > 0 ||
-		len(v.Skills) > 0 ||
-		len(v.SkillQuality) > 0 ||
-		len(v.Errors) > 0 ||
-		len(v.Outputs) > 0 ||
-		len(v.Examples) > 0 ||
-		len(v.PublicContentLeakage) > 0 ||
-		len(v.Diagnostics) > 0
-}
-
 func BuildInputView(f facts.Facts) InputView {
 	selected := newInputSelection(f)
 	selected.addChangedReviewCandidates()
@@ -122,17 +104,16 @@ func BuildInputView(f facts.Facts) InputView {
 	}
 
 	return InputView{
-		SchemaVersion:        f.SchemaVersion,
-		ChangedSummary:       changedSummary(f),
-		RuleSummary:          ruleSummary(f.Diagnostics),
-		Commands:             selected.commandInputs(),
-		Skills:               selected.skillInputs(),
-		SkillQuality:         selected.skillQualityInputs(),
-		Errors:               selected.errorInputs(),
-		Outputs:              selected.outputInputs(),
-		Examples:             selected.exampleInputs(),
-		PublicContentLeakage: selected.publicContentInputs(),
-		Diagnostics:          viewDiagnostics,
+		SchemaVersion:  f.SchemaVersion,
+		ChangedSummary: changedSummary(f),
+		RuleSummary:    ruleSummary(f.Diagnostics),
+		Commands:       selected.commandInputs(),
+		Skills:         selected.skillInputs(),
+		SkillQuality:   selected.skillQualityInputs(),
+		Errors:         selected.errorInputs(),
+		Outputs:        selected.outputInputs(),
+		Examples:       selected.exampleInputs(),
+		Diagnostics:    viewDiagnostics,
 	}
 }
 
@@ -157,11 +138,6 @@ func (s *inputSelection) addChangedReviewCandidates() {
 			s.outputs[i] = true
 		}
 	}
-	for i, item := range s.f.PublicContent {
-		if publicContentReviewCandidate(item) {
-			s.publicContent[i] = true
-		}
-	}
 }
 
 func commandReviewCandidate(cmd facts.CommandFact) bool {
@@ -181,31 +157,25 @@ func outputReviewCandidate(_ facts.OutputFact) bool {
 	return false
 }
 
-func publicContentReviewCandidate(item facts.PublicContentFact) bool {
-	return item.Rule == "public_content_semantic_candidate"
-}
-
 type inputSelection struct {
-	f             facts.Facts
-	commands      []bool
-	skills        []bool
-	skillQuality  []bool
-	errors        []bool
-	outputs       []bool
-	examples      []bool
-	publicContent []bool
+	f            facts.Facts
+	commands     []bool
+	skills       []bool
+	skillQuality []bool
+	errors       []bool
+	outputs      []bool
+	examples     []bool
 }
 
 func newInputSelection(f facts.Facts) *inputSelection {
 	return &inputSelection{
-		f:             f,
-		commands:      make([]bool, len(f.Commands)),
-		skills:        make([]bool, len(f.Skills)),
-		skillQuality:  make([]bool, len(f.SkillQuality)),
-		errors:        make([]bool, len(f.Errors)),
-		outputs:       make([]bool, len(f.Outputs)),
-		examples:      make([]bool, len(f.Examples)),
-		publicContent: make([]bool, len(f.PublicContent)),
+		f:            f,
+		commands:     make([]bool, len(f.Commands)),
+		skills:       make([]bool, len(f.Skills)),
+		skillQuality: make([]bool, len(f.SkillQuality)),
+		errors:       make([]bool, len(f.Errors)),
+		outputs:      make([]bool, len(f.Outputs)),
+		examples:     make([]bool, len(f.Examples)),
 	}
 }
 
@@ -224,8 +194,6 @@ func (s *inputSelection) diagnosticContext(diag facts.DiagnosticFact) *inputSele
 		s.addDiagnosticExamples(out, diag)
 	case diag.Rule == "no_bare_helper_error":
 		s.addDiagnosticErrors(out, diag)
-	case strings.HasPrefix(diag.Rule, "public_content_"):
-		s.addDiagnosticPublicContent(out, diag)
 	}
 	return out
 }
@@ -288,15 +256,6 @@ func (s *inputSelection) addDiagnosticExamples(out *inputSelection, diag facts.D
 	}
 }
 
-func (s *inputSelection) addDiagnosticPublicContent(out *inputSelection, diag facts.DiagnosticFact) {
-	for i, item := range s.f.PublicContent {
-		if diagnosticLocationMatches(diag.File, diag.Line, item.File, item.Line) ||
-			diag.Rule == item.Rule {
-			out.publicContent[i] = true
-		}
-	}
-}
-
 func includeDiagnosticInView(diag facts.DiagnosticFact, selected, context *inputSelection) bool {
 	if diag.Action == report.ActionReject {
 		return true
@@ -311,7 +270,6 @@ func (s *inputSelection) merge(other *inputSelection) {
 	mergeSelections(s.errors, other.errors)
 	mergeSelections(s.outputs, other.outputs)
 	mergeSelections(s.examples, other.examples)
-	mergeSelections(s.publicContent, other.publicContent)
 }
 
 func (s *inputSelection) intersects(other *inputSelection) bool {
@@ -320,8 +278,7 @@ func (s *inputSelection) intersects(other *inputSelection) bool {
 		selectionsIntersect(s.skillQuality, other.skillQuality) ||
 		selectionsIntersect(s.errors, other.errors) ||
 		selectionsIntersect(s.outputs, other.outputs) ||
-		selectionsIntersect(s.examples, other.examples) ||
-		selectionsIntersect(s.publicContent, other.publicContent)
+		selectionsIntersect(s.examples, other.examples)
 }
 
 func (s *inputSelection) commandInputs() []CommandInput {
@@ -394,16 +351,6 @@ func (s *inputSelection) exampleInputs() []ExampleInput {
 	return out
 }
 
-func (s *inputSelection) publicContentInputs() []PublicContentInput {
-	out := make([]PublicContentInput, 0, countSelected(s.publicContent))
-	for i, ok := range s.publicContent {
-		if ok {
-			out = append(out, PublicContentInput{FactRef: factRef("public_content", i), PublicContentFact: s.f.PublicContent[i]})
-		}
-	}
-	return out
-}
-
 func changedSummary(f facts.Facts) ChangedSummary {
 	domains := map[string]bool{}
 	sources := map[string]bool{}
@@ -455,10 +402,6 @@ func changedSummary(f facts.Facts) ChangedSummary {
 		addNonEmpty(domains, example.Domain)
 		addNonEmpty(sources, example.Source)
 	}
-	for _, item := range f.PublicContent {
-		out.PublicContent++
-		addNonEmpty(sources, item.Source)
-	}
 	out.Domains = sortedViewSetKeys(domains)
 	out.Sources = sortedViewSetKeys(sources)
 	return out
@@ -491,8 +434,7 @@ func semanticDiagnosticRule(rule string) bool {
 		strings.HasPrefix(rule, "default_output") ||
 		strings.HasPrefix(rule, "skill_") ||
 		strings.HasPrefix(rule, "example_dry_run") ||
-		rule == "no_bare_helper_error" ||
-		strings.HasPrefix(rule, "public_content_")
+		rule == "no_bare_helper_error"
 }
 
 func diagnosticCommandMatches(diag facts.DiagnosticFact, values ...string) bool {

internal/qualitygate/semantic/view_test.go

@@ -77,122 +77,6 @@ func TestInputViewKeepsChangedReviewCandidatesWithOriginalRefs(t *testing.T) {
 	}
 }
 
-func TestInputViewIncludesPublicContentLeakage(t *testing.T) {
-	f := facts.Facts{
-		SchemaVersion: 1,
-		PublicContent: []facts.PublicContentFact{{
-			Rule:    "public_content_generic_credential",
-			Action:  report.ActionReject,
-			File:    "docs/public.md",
-			Line:    4,
-			Excerpt: "api_key = <redacted>",
-			Message: "generic credential assignment",
-		}},
-		Diagnostics: []facts.DiagnosticFact{{
-			Rule:    "public_content_generic_credential",
-			Action:  report.ActionReject,
-			File:    "docs/public.md",
-			Line:    4,
-			Message: "generic credential assignment",
-		}},
-	}
-
-	view := BuildInputView(f)
-	if len(view.PublicContentLeakage) != 1 {
-		t.Fatalf("public content leakage len = %d, want 1", len(view.PublicContentLeakage))
-	}
-	if got := view.PublicContentLeakage[0].FactRef; got != "facts.public_content[0]" {
-		t.Fatalf("public content fact ref = %q", got)
-	}
-	if len(view.Diagnostics) != 1 {
-		t.Fatalf("diagnostics len = %d, want 1", len(view.Diagnostics))
-	}
-}
-
-func TestInputViewIncludesPublicContentSemanticCandidatesWithoutDiagnostics(t *testing.T) {
-	f := facts.Facts{
-		SchemaVersion: 1,
-		PublicContent: []facts.PublicContentFact{{
-			Rule:    "public_content_semantic_candidate",
-			Action:  report.ActionWarning,
-			File:    "docs/public.md",
-			Line:    1,
-			Source:  "file",
-			Excerpt: "public prose that needs semantic review",
-			Message: "public contribution contains text for semantic public content review",
-		}},
-	}
-
-	view := BuildInputView(f)
-	if len(view.PublicContentLeakage) != 1 {
-		t.Fatalf("semantic candidate len = %d, want 1", len(view.PublicContentLeakage))
-	}
-	if got := view.PublicContentLeakage[0].FactRef; got != "facts.public_content[0]" {
-		t.Fatalf("semantic candidate fact ref = %q", got)
-	}
-	if len(view.Diagnostics) != 0 {
-		t.Fatalf("semantic candidate should not require diagnostics, got %#v", view.Diagnostics)
-	}
-}
-
-func TestPromptIncludesSanitizedPublicContentExcerpt(t *testing.T) {
-	scopeText := "pri" + "vate rollout"
-	f := facts.Facts{
-		SchemaVersion: 1,
-		PublicContent: []facts.PublicContentFact{{
-			Rule:    "public_content_semantic_candidate",
-			Action:  report.ActionWarning,
-			File:    "docs/public.md",
-			Line:    1,
-			Source:  "file",
-			Excerpt: `semantic signals: pri` + `vate_scope,roadmap_detail; excerpt: "` + scopeText + ` token=<redacted>"`,
-			Message: "public contribution contains text for semantic public content review",
-		}},
-	}
-
-	view := BuildInputView(f)
-	if len(view.PublicContentLeakage) != 1 {
-		t.Fatalf("semantic candidate len = %d, want 1", len(view.PublicContentLeakage))
-	}
-	if got := view.PublicContentLeakage[0].Excerpt; !strings.Contains(got, scopeText) || !strings.Contains(got, "token=<redacted>") {
-		t.Fatalf("semantic candidate excerpt missing from view: %q", got)
-	}
-
-	messages := BuildPrompt(f)
-	if len(messages) != 2 {
-		t.Fatalf("messages len = %d, want 2", len(messages))
-	}
-	if !strings.Contains(messages[1].Content, scopeText) || !strings.Contains(messages[1].Content, "redacted") {
-		t.Fatalf("prompt missing sanitized public content excerpt: %s", messages[1].Content)
-	}
-	if strings.Contains(messages[1].Content, "real-"+"secret-value") {
-		t.Fatalf("prompt leaked raw sensitive value %q", messages[1].Content)
-	}
-}
-
-func TestInputViewExcludesPublicContentWarningsWithoutSemanticCandidate(t *testing.T) {
-	f := facts.Facts{
-		SchemaVersion: 1,
-		PublicContent: []facts.PublicContentFact{{
-			Rule:    "public_content_" + "pri" + "vate_ipv4",
-			Action:  report.ActionWarning,
-			File:    "docs/network.md",
-			Line:    1,
-			Source:  "file",
-			Excerpt: "192.168." + "0.10",
-			Message: "public contribution contains a pri" + "vate-network IP address",
-		}},
-	}
-
-	view := BuildInputView(f)
-	if len(view.PublicContentLeakage) != 0 {
-		t.Fatalf("warning-only public content should not enter semantic view: %#v", view.PublicContentLeakage)
-	}
-	if len(view.Diagnostics) != 0 {
-		t.Fatalf("warning-only public content should not add diagnostics: %#v", view.Diagnostics)
-	}
-}
-
 func TestInputViewSummarizesBroadChangedCommandSurface(t *testing.T) {
 	f := broadChangedFacts(434, 44)
 

internal/qualitygate/semantic/waiver.go

@@ -138,10 +138,6 @@ func parseWaiver(parts []string, lineNo int) (Waiver, error) {
 		if item.SourceFile == "" || item.Line == 0 {
 			return Waiver{}, fmt.Errorf("%s:%d: %s waiver requires source_file and line", waiverPath, lineNo, item.FactKind)
 		}
-	case "public_content":
-		if item.SourceFile == "" || item.Line == 0 || item.CommandPath != "" {
-			return Waiver{}, fmt.Errorf("%s:%d: public_content waiver requires source_file and line only", waiverPath, lineNo)
-		}
 	case "command", "output":
 		if item.CommandPath == "" {
 			return Waiver{}, fmt.Errorf("%s:%d: %s waiver requires command_path", waiverPath, lineNo, item.FactKind)

internal/qualitygate/semantic/waiver_test.go

@@ -21,27 +21,24 @@ func TestLoadWaivers(t *testing.T) {
 
 	writeSemanticFile(t, repo, "waivers.txt", "# waiver_id\tcategory\tfact_kind\tsource_file\tline\tcommand_path\towner\treason\tadded_at\texpires_at\n"+
 		"wiki-move-202606\tskill_quality\tskill\tskills/lark-wiki/SKILL.md\t30\t\twiki-owner\tmigration\t2026-06-08\t2026-07-15\n"+
-		"wiki-move-202606\tskill_quality\tskill\tskills/lark-wiki/references/move.md\t12\t\twiki-owner\tmigration\t2026-06-08\t2026-07-15\n"+
-		"public-doc-202606\tpublic_content_leakage\tpublic_content\tdocs/public.md\t4\t\tsecurity-owner\treviewed false positive\t2026-06-08\t2026-07-15\n")
+		"wiki-move-202606\tskill_quality\tskill\tskills/lark-wiki/references/move.md\t12\t\twiki-owner\tmigration\t2026-06-08\t2026-07-15\n")
 	w, diags, err = LoadWaivers(repo, now)
 	if err != nil {
 		t.Fatalf("LoadWaivers() error = %v", err)
 	}
-	if len(diags) != 0 || len(w.Items) != 3 {
+	if len(diags) != 0 || len(w.Items) != 2 {
 		t.Fatalf("LoadWaivers() = %#v %#v", w, diags)
 	}
 
 	for name, body := range map[string]string{
-		"bad columns":                     "one\ttoo-few\n",
-		"bad id":                          "BAD\terror_hint\terror\tcmd/root.go\t1\t\to\tr\t2026-06-08\t2026-07-15\n",
-		"bad fact kind":                   "id1\terror_hint\tskill_quality\tcmd/root.go\t1\t\to\tr\t2026-06-08\t2026-07-15\n",
-		"missing owner":                   "id1\terror_hint\terror\tcmd/root.go\t1\t\t\tr\t2026-06-08\t2026-07-15\n",
-		"missing line":                    "id1\terror_hint\terror\tcmd/root.go\t\t\to\tr\t2026-06-08\t2026-07-15\n",
-		"missing command":                 "id1\tdefault_output\toutput\t\t\t\to\tr\t2026-06-08\t2026-07-15\n",
-		"public content missing line":     "id1\tpublic_content_leakage\tpublic_content\tdocs/public.md\t\t\to\tr\t2026-06-08\t2026-07-15\n",
-		"public content command selector": "id1\tpublic_content_leakage\tpublic_content\t\t\tcmd/foo\to\tr\t2026-06-08\t2026-07-15\n",
-		"bad source path":                 "id1\terror_hint\terror\t../cmd/root.go\t1\t\to\tr\t2026-06-08\t2026-07-15\n",
-		"bad date format":                 "id1\terror_hint\terror\tcmd/root.go\t1\t\to\tr\t20260608\t2026-07-15\n",
+		"bad columns":     "one\ttoo-few\n",
+		"bad id":          "BAD\terror_hint\terror\tcmd/root.go\t1\t\to\tr\t2026-06-08\t2026-07-15\n",
+		"bad fact kind":   "id1\terror_hint\tskill_quality\tcmd/root.go\t1\t\to\tr\t2026-06-08\t2026-07-15\n",
+		"missing owner":   "id1\terror_hint\terror\tcmd/root.go\t1\t\t\tr\t2026-06-08\t2026-07-15\n",
+		"missing line":    "id1\terror_hint\terror\tcmd/root.go\t\t\to\tr\t2026-06-08\t2026-07-15\n",
+		"missing command": "id1\tdefault_output\toutput\t\t\t\to\tr\t2026-06-08\t2026-07-15\n",
+		"bad source path": "id1\terror_hint\terror\t../cmd/root.go\t1\t\to\tr\t2026-06-08\t2026-07-15\n",
+		"bad date format": "id1\terror_hint\terror\tcmd/root.go\t1\t\to\tr\t20260608\t2026-07-15\n",
 	} {
 		t.Run(name, func(t *testing.T) {
 			writeSemanticFile(t, repo, "waivers.txt", body)

internal/registry/scope_priorities.json

@@ -5609,21 +5609,6 @@
     "final_score": "80.0587",
     "recommend": "false"
   },
-  {
-    "scope_name": "im:chat.nickname:read",
-    "final_score": "88.0587",
-    "recommend": "true"
-  },
-  {
-    "scope_name": "im:chat.nickname:write",
-    "final_score": "79.5982",
-    "recommend": "true"
-  },
-  {
-    "scope_name": "im:chat.user_setting:write",
-    "final_score": "83.6587",
-    "recommend": "true"
-  },
   {
     "scope_name": "im:chat.user_setting:read",
     "final_score": "88.0587",

package.json

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

scripts/ci-quality-summary-publish.js

@@ -45,10 +45,6 @@ async function publishTargetStillCurrent(github, context, core, target, phase =
     repo: context.repo.repo,
     pull_number: target.pr,
   });
-  if (pr.state !== "open") {
-    core.notice(`PR quality summary skipped: PR is no longer open before ${phase}`);
-    return false;
-  }
   if (pr.head.sha !== target.headSha) {
     core.notice(`PR quality summary skipped: PR head changed before ${phase}`);
     return false;

scripts/ci-quality-summary-publish.test.js

@@ -152,25 +152,6 @@ describe("ci-quality-summary-publish", () => {
     });
   });
 
-  it("does not publish a summary when the PR closes before comment creation", async () => {
-    await withPublishTempDir(async ({ calls }) => {
-      await publish({
-        github: fakeGithub(calls, {
-          jobs: [{ name: "unit-test", conclusion: "failure", html_url: "https://github.example/jobs/1" }],
-          pullResponses: [
-            currentPullResponse(),
-            currentPullResponse({ state: "closed" }),
-          ],
-        }),
-        context: workflowRunContext({ conclusion: "failure" }),
-        core: silentCore(calls),
-      });
-
-      assert.equal(calls.comments.length, 0);
-      assert.match(calls.notices.join("\n"), /PR is no longer open/);
-    });
-  });
-
   it("does not delete an existing summary when the PR base changes before cleanup", async () => {
     await withPublishTempDir(async ({ calls }) => {
       await publish({
@@ -357,7 +338,6 @@ function fakeGithub(calls, options = {}) {
 function currentPullResponse(overrides = {}) {
   return {
     data: {
-      state: overrides.state || "open",
       head: { sha: overrides.headSha || process.env.CI_QUALITY_SUMMARY_HEAD_SHA },
       base: {
         sha: overrides.baseSha || process.env.CI_QUALITY_SUMMARY_BASE_SHA,

scripts/ci-workflow.test.sh

@@ -5,42 +5,26 @@
 set -euo pipefail
 
 workflow=".github/workflows/ci.yml"
-job_section() {
-  local job="$1"
-  awk -v job="$job" '
-    $0 == "  " job ":" { in_job = 1; print; next }
-    in_job && /^  [A-Za-z0-9_-]+:/ { exit }
-    in_job { print }
-  ' "$workflow"
-}
 workflow_permissions="$(awk '
   /^permissions:/ { in_permissions = 1; print; next }
   in_permissions && /^[^[:space:]]/ { exit }
   in_permissions { print }
 ' "$workflow")"
-fast_gate_section="$(job_section fast-gate)"
-unit_test_section="$(job_section unit-test)"
 lint_section="$(awk '
   /^  lint:/ { in_job = 1 }
   in_job { print }
-  /^  script-test:/ { exit }
+  /^  deterministic-gate:/ { exit }
 ' "$workflow")"
-script_test_section="$(job_section script-test)"
 deterministic_section="$(awk '
   /^  deterministic-gate:/ { in_job = 1 }
   in_job { print }
   /^  coverage:/ { exit }
 ' "$workflow")"
-coverage_job_section="$(job_section coverage)"
-deadcode_section="$(job_section deadcode)"
-dry_run_section="$(job_section e2e-dry-run)"
 section="$(awk '
   /^  e2e-live:/ { in_job = 1 }
   in_job { print }
   /^  security:/ { exit }
 ' "$workflow")"
-security_section="$(job_section security)"
-license_header_section="$(job_section license-header)"
 results_section="$(awk '
   /^  results:/ { in_job = 1 }
   in_job { print }
@@ -114,94 +98,13 @@ if ! grep -Fq "make quality-gate" <<<"$deterministic_section"; then
   exit 1
 fi
 
-if ! grep -Fq "Write public content metadata" <<<"$deterministic_section"; then
-  echo "deterministic-gate should write PR title/body metadata before quality-gate"
-  exit 1
-fi
-
-if ! grep -Fq "types: [opened, synchronize, reopened, edited]" "$workflow"; then
-  echo "CI pull_request trigger should include edited so PR title/body changes are rescanned"
-  exit 1
-fi
-
-if ! grep -Fq "script-test:" <<<"$script_test_section"; then
-  echo "CI should run make script-test so workflow and publisher contract tests are not local-only"
-  exit 1
-fi
-
-if ! grep -Fq "make script-test" <<<"$script_test_section"; then
-  echo "script-test job should invoke make script-test"
-  exit 1
-fi
-
-if ! grep -Fq "actions/setup-node" <<<"$script_test_section"; then
-  echo "script-test job should install Node for JavaScript workflow tests"
-  exit 1
-fi
-
-if grep -Fq '${{ secrets.' <<<"$script_test_section"; then
-  echo "script-test must not reference secrets"
-  exit 1
-fi
-
-if grep -Fq "metadata-gate:" "$workflow"; then
-  echo "metadata-gate should not run alongside deterministic-gate because both would upload the same facts artifact"
-  exit 1
-fi
-
-if grep -Fq "github.event.action != 'edited'" <<<"$fast_gate_section"; then
-  echo "fast-gate must run on pull_request edited events so title/body edits cannot replace failed CI with a light success"
-  exit 1
-fi
-
-for full_job in \
-  "$unit_test_section" \
-  "$lint_section" \
-  "$script_test_section" \
-  "$deterministic_section" \
-  "$coverage_job_section" \
-  "$dry_run_section" \
-  "$security_section"; do
-  if grep -Fq "github.event.action != 'edited'" <<<"$full_job"; then
-    echo "full CI jobs must run on pull_request edited events; do not skip title/body-only edits"
-    exit 1
-  fi
-done
-
-for pull_request_job in "$deadcode_section" "$license_header_section"; do
-  if grep -Fq "github.event.action != 'edited'" <<<"$pull_request_job"; then
-    echo "pull_request-only CI jobs must run on edited events"
-    exit 1
-  fi
-done
-
-if grep -Fq '${{ secrets.' <<<"$deterministic_section"; then
-  echo "deterministic-gate must not reference secrets"
-  exit 1
-fi
-
-if ! grep -Fq "PUBLIC_CONTENT_METADATA=" <<<"$deterministic_section"; then
-  echo "deterministic-gate should pass public content metadata into make quality-gate"
-  exit 1
-fi
-
-if ! grep -Fq "PR_BRANCH:" <<<"$deterministic_section"; then
-  echo "deterministic-gate should pass the pull request branch into public content metadata"
-  exit 1
-fi
-
 if ! grep -Fq "name: quality-gate-facts-\${{ github.event.pull_request.base.sha }}-\${{ github.event.pull_request.head.sha }}" <<<"$deterministic_section"; then
   echo "deterministic-gate should upload base/head-bound quality-gate-facts for semantic review"
   exit 1
 fi
 
-if ! grep -Fq "needs: [unit-test, lint, script-test, deterministic-gate]" "$workflow"; then
-  echo "E2E jobs should wait for script-test and deterministic-gate"
-  exit 1
-fi
-
-if ! grep -Fq "script-test" <<<"$results_section"; then
-  echo "results job should include script-test"
+if ! grep -Fq "needs: [unit-test, lint, deterministic-gate]" "$workflow"; then
+  echo "E2E jobs should wait for deterministic-gate"
   exit 1
 fi
 
@@ -307,11 +210,6 @@ if ! grep -Fq "go run ./internal/qualitygate/cmd/manifest-export" <<<"$make_outp
   exit 1
 fi
 
-if ! grep -Fq -- "--public-content-metadata .tmp/quality-gate/public-content-metadata.json" <<<"$make_output"; then
-  echo "quality-gate check should consume public content metadata"
-  exit 1
-fi
-
 if ! grep -Fq -- "--manifest .tmp/quality-gate/command-manifest.json" <<<"$make_output" ||
    ! grep -Fq -- "--command-index .tmp/quality-gate/command-index.json" <<<"$make_output"; then
   echo "quality-gate check should consume both exported command snapshots"

scripts/semantic-review-publish.js

@@ -175,7 +175,7 @@ function inlineCode(value) {
 }
 
 function parseEvidenceRef(ref) {
-  const match = /^facts\.(commands|skills|errors|outputs|public_content)\[(\d+)\]$/.exec(String(ref || ""));
+  const match = /^facts\.(commands|skills|errors|outputs)\[(\d+)\]$/.exec(String(ref || ""));
   if (!match) {
     return null;
   }
@@ -230,20 +230,6 @@ function evidenceLocation(facts, ref) {
         return { kind: parsed.kind, command: item.path, label: item.path };
       }
       return null;
-    case "public_content":
-      if (item.file && Number.isInteger(item.line) && item.line > 0) {
-        const label = `${item.file}:${item.line}`;
-        if (item.file === "branch" || item.file === "pull_request_metadata" || String(item.file).startsWith("commit:")) {
-          return { kind: parsed.kind, label };
-        }
-        return {
-          kind: parsed.kind,
-          path: item.file,
-          line: item.line,
-          label,
-        };
-      }
-      return null;
     default:
       return null;
   }
@@ -859,10 +845,6 @@ async function publishTargetStillCurrent(github, context, core, target, phase =
     repo: context.repo.repo,
     pull_number: target.pr,
   });
-  if (pr.state !== "open") {
-    core.notice(`semantic review skipped: PR is no longer open before ${phase}`);
-    return false;
-  }
   if (pr.head.sha !== target.headSha) {
     core.notice(`semantic review skipped: PR head changed before ${phase}`);
     return false;

scripts/semantic-review-publish.test.js

@@ -202,100 +202,6 @@ describe("semantic-review-publish", () => {
     assert.equal(selectInlineTarget({ evidence: ["facts.errors[0]"] }, facts, changedLineIndex), null);
   });
 
-  it("maps public content evidence to changed files but not virtual metadata", () => {
-    const restrictedScope = "pri" + "vate";
-    const facts = {
-      public_content: [
-        {
-          rule: "public_content_semantic_candidate",
-          action: "WARNING",
-          file: "docs/public-roadmap.md",
-          line: 4,
-          source: "file",
-        },
-        {
-          rule: "public_content_semantic_candidate",
-          action: "WARNING",
-          file: "pull_request_metadata",
-          line: 1,
-          source: "metadata",
-        },
-        {
-          rule: "public_content_automation_branch",
-          action: "WARNING",
-          file: "branch",
-          line: 1,
-          source: "branch",
-        },
-        {
-          rule: "public_content_change_id_trailer",
-          action: "REJECT",
-          file: "commit:1234abc",
-          line: 3,
-          source: "commit",
-        },
-      ],
-    };
-    const changedLineIndex = buildChangedLineIndex([{
-      filename: "docs/public-roadmap.md",
-      patch: [
-        "@@ -3,2 +3,3 @@",
-        " context",
-        "+Specific " + restrictedScope + " roadmap detail",
-      ].join("\n"),
-    }]);
-
-    assert.deepEqual(
-      selectInlineTarget({ evidence: ["facts.public_content[0]"] }, facts, changedLineIndex),
-      { path: "docs/public-roadmap.md", line: 4 },
-    );
-    assert.equal(selectInlineTarget({ evidence: ["facts.public_content[1]"] }, facts, changedLineIndex), null);
-    assert.equal(selectInlineTarget({ evidence: ["facts.public_content[2]"] }, facts, changedLineIndex), null);
-    assert.equal(selectInlineTarget({ evidence: ["facts.public_content[3]"] }, facts, changedLineIndex), null);
-
-    const markdown = buildSummaryMarkdown({
-      block_mode: true,
-      blockers: [{
-        category: "public_content_leakage",
-        severity: "major",
-        review_action: "must_fix",
-        evidence: ["facts.public_content[1]"],
-        fingerprint: "public-content-metadata",
-        message: "PR metadata contains " + restrictedScope + " rollout detail",
-        suggested_action: "Move " + restrictedScope + " detail to an internal channel.",
-      }],
-      warnings: [],
-    }, facts);
-    assert.match(markdown, /pull_request_metadata:1/);
-
-    const virtualMarkdown = buildSummaryMarkdown({
-      block_mode: true,
-      blockers: [
-        {
-          category: "public_content_leakage",
-          severity: "major",
-          review_action: "must_fix",
-          evidence: ["facts.public_content[2]"],
-          fingerprint: "public-content-branch",
-          message: "Branch name looks automation-owned.",
-          suggested_action: "Use a maintainer-owned public branch name.",
-        },
-        {
-          category: "public_content_leakage",
-          severity: "major",
-          review_action: "must_fix",
-          evidence: ["facts.public_content[3]"],
-          fingerprint: "public-content-commit",
-          message: "Commit trailer contains " + restrictedScope + " review metadata.",
-          suggested_action: "Remove " + restrictedScope + " review metadata from commits.",
-        },
-      ],
-      warnings: [],
-    }, facts);
-    assert.match(virtualMarkdown, /branch:1/);
-    assert.match(virtualMarkdown, /commit:1234abc:3/);
-  });
-
   it("builds finding markers from stable fingerprints and evidence identity", () => {
     const factsA = {
       skills: [{
@@ -709,35 +615,6 @@ describe("semantic-review-publish", () => {
     });
   });
 
-  it("skips publishing when the PR closes after verification", async () => {
-    await withPublishTempDir(async ({ calls }) => {
-      fs.writeFileSync("decision.json", JSON.stringify({
-        block_mode: true,
-        blockers: [],
-        warnings: [],
-      }), "utf8");
-
-      await publish({
-        github: fakeGithub(calls, {
-          currentPullRequest: {
-            state: "closed",
-            head: { sha: "0123456789abcdef0123456789abcdef01234567" },
-            base: {
-              sha: "fedcba9876543210fedcba9876543210fedcba98",
-              repo: { id: 123 },
-            },
-          },
-        }),
-        context: workflowRunContext(),
-        core: silentCore(calls),
-      });
-
-      assert.equal(calls.checks.length, 0);
-      assert.equal(calls.comments.length, 0);
-      assert.match(calls.notices[0], /PR is no longer open before publishing/);
-    });
-  });
-
   it("rejects publishing when the PR base repo changed after verification", async () => {
     await withPublishTempDir(async ({ calls }) => {
       fs.writeFileSync("decision.json", JSON.stringify({
@@ -2346,8 +2223,8 @@ function fakeGithub(calls, options = {}) {
         },
       },
       pulls: {
-        get: async () => {
-          const pull = Array.isArray(options.currentPullRequests)
+        get: async () => ({
+          data: Array.isArray(options.currentPullRequests)
             ? options.currentPullRequests[Math.min(pullGetCount++, options.currentPullRequests.length - 1)]
             : options.currentPullRequest || {
             head: { sha: process.env.SEMANTIC_REVIEW_HEAD_SHA },
@@ -2355,9 +2232,8 @@ function fakeGithub(calls, options = {}) {
               sha: process.env.SEMANTIC_REVIEW_BASE_SHA,
               repo: { id: 123 },
             },
-          };
-          return { data: { state: "open", ...pull } };
-        },
+          },
+        }),
         listFiles() {},
         listReviewComments() {},
         createReviewComment: async (args) => {

scripts/semantic-review-verify-artifact.js

@@ -229,36 +229,6 @@ function requireSafePath(value, path) {
   return file;
 }
 
-function requirePublicContentFile(value, path) {
-  const file = requireString(value, path);
-  if (file === "branch" || file === "pull_request_metadata" || /^commit:[0-9a-f]{7,40}$/.test(file)) {
-    return file;
-  }
-  if (file.startsWith("commit:")) {
-    throw new Error(`facts JSON ${path} must be a valid public content location`);
-  }
-  requireSafePath(file, path);
-  if (
-    file === "" ||
-    file === "." ||
-    file.startsWith("./") ||
-    file.includes("\\") ||
-    file.includes("\0") ||
-    file.split("/").includes(".git") ||
-    /^[A-Za-z][A-Za-z0-9+.-]*:/.test(file)
-  ) {
-    throw new Error(`facts JSON ${path} must be a repository-relative path`);
-  }
-  return file;
-}
-
-function requirePositiveLine(value, path) {
-  requireLine(value, path);
-  if (value === 0) {
-    throw new Error(`facts JSON ${path} must be a positive line number`);
-  }
-}
-
 function requireStringArray(value, path, { optional = false } = {}) {
   if (value === undefined || value === null) {
     if (optional) {
@@ -451,20 +421,6 @@ function verifyFactsJSON(data) {
   for (const [i, value] of requireArray(facts, "examples").entries()) {
     verifyCommandExample(value, `examples[${i}]`);
   }
-  for (const [i, value] of requireArray(facts, "public_content").entries()) {
-    const item = requireObject(value, `public_content[${i}]`);
-    requireString(item.rule, `public_content[${i}].rule`);
-    const action = requireString(item.action, `public_content[${i}].action`);
-    if (!VALID_ACTIONS.has(action)) {
-      throw new Error(`facts JSON public_content[${i}].action is invalid`);
-    }
-    requirePublicContentFile(item.file, `public_content[${i}].file`);
-    requirePositiveLine(item.line, `public_content[${i}].line`);
-    requireString(item.source, `public_content[${i}].source`, { optional: true });
-    requireString(item.excerpt, `public_content[${i}].excerpt`, { optional: true });
-    requireString(item.message, `public_content[${i}].message`, { optional: true });
-    requireString(item.suggestion, `public_content[${i}].suggestion`, { optional: true });
-  }
   for (const [i, value] of requireArray(facts, "diagnostics").entries()) {
     const item = requireObject(value, `diagnostics[${i}]`);
     requireString(item.rule, `diagnostics[${i}].rule`);

scripts/semantic-review-verify-artifact.test.js

@@ -67,43 +67,7 @@ describe("verifyZipEntries", () => {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), "semantic-review-zip-"));
     const zipPath = path.join(dir, "facts.zip");
     const outPath = path.join(dir, "facts.json");
-    const restrictedScope = "pri" + "vate";
-    const facts = Buffer.from(JSON.stringify({
-      schema_version: 1,
-      public_content: [
-        {
-          rule: "public_content_semantic_candidate",
-          action: "WARNING",
-          file: "pull_request_metadata",
-          line: 1,
-          source: "metadata",
-          excerpt: "public release notes mention an internal rollout plan",
-          message: "public contribution may contain sensitive implementation detail",
-          suggestion: "move internal detail to " + restrictedScope + " discussion",
-        },
-        {
-          rule: "public_content_change_id_trailer",
-          action: "REJECT",
-          file: "commit:1234abc",
-          line: 3,
-          source: "commit",
-        },
-        {
-          rule: "public_content_automation_branch",
-          action: "WARNING",
-          file: "branch",
-          line: 1,
-          source: "branch",
-        },
-        {
-          rule: "public_content_" + "pri" + "vate_ipv4",
-          action: "WARNING",
-          file: "docs/public-network.md",
-          line: 7,
-          source: "file",
-        },
-      ],
-    }) + "\n");
+    const facts = Buffer.from('{"schema_version":1}\n');
     const zip = makeZip([{ fileName: "facts.json", data: facts, mode: 0o100644 }]);
     fs.writeFileSync(zipPath, zip);
 
@@ -139,19 +103,6 @@ describe("verifyZipEntries", () => {
       ["bad-error-path", Buffer.from('{"schema_version":1,"errors":[{"file":"../x.go","line":1,"boundary":true,"uses_structured_error":false,"has_hint":false,"hint_action_count":0,"required_hint":true,"retryable":false}]}'), /errors\[0\]\.file/],
       ["bad-example-dry-run", Buffer.from('{"schema_version":1,"examples":[{"raw":"lark-cli docs +fetch","source_file":"skills/lark-doc/SKILL.md","line":3,"executable":true,"dry_run":{"method":"GET","url":"/open-apis/docx","query":{"page_size":["20",1]}}}]}'), /examples\[0\]\.dry_run\.query\.page_size\[1\]/],
       ["bad-output-field", Buffer.from(JSON.stringify({ schema_version: 1, outputs: [{ command: "drive files list", fields: ["ok", "x".repeat(9000)] }] })), /outputs\[0\]\.fields\[1\]/],
-      ["non-array-public-content", Buffer.from('{"schema_version":1,"public_content":{}}'), /public_content must be an array/],
-      ["bad-public-content-item", Buffer.from('{"schema_version":1,"public_content":["not-object"]}'), /public_content\[0\]/],
-      ["bad-public-content-action", Buffer.from('{"schema_version":1,"public_content":[{"rule":"public_content_semantic_candidate","action":"BLOCK","file":"pull_request_metadata","line":1}]}'), /public_content\[0\]\.action/],
-      ["bad-public-content-path", Buffer.from('{"schema_version":1,"public_content":[{"rule":"public_content_semantic_candidate","action":"WARNING","file":"../x","line":1}]}'), /public_content\[0\]\.file/],
-      ["dot-slash-public-content-path", Buffer.from('{"schema_version":1,"public_content":[{"rule":"public_content_semantic_candidate","action":"WARNING","file":"./foo","line":1}]}'), /public_content\[0\]\.file/],
-      ["empty-public-content-path", Buffer.from('{"schema_version":1,"public_content":[{"rule":"public_content_semantic_candidate","action":"WARNING","file":"","line":1}]}'), /public_content\[0\]\.file/],
-      ["dot-public-content-path", Buffer.from('{"schema_version":1,"public_content":[{"rule":"public_content_semantic_candidate","action":"WARNING","file":".","line":1}]}'), /public_content\[0\]\.file/],
-      ["url-public-content-path", Buffer.from('{"schema_version":1,"public_content":[{"rule":"public_content_semantic_candidate","action":"WARNING","file":"https://example.invalid/x","line":1}]}'), /public_content\[0\]\.file/],
-      ["dotgit-public-content-path", Buffer.from('{"schema_version":1,"public_content":[{"rule":"public_content_semantic_candidate","action":"WARNING","file":".git/config","line":1}]}'), /public_content\[0\]\.file/],
-      ["windows-public-content-path", Buffer.from('{"schema_version":1,"public_content":[{"rule":"public_content_semantic_candidate","action":"WARNING","file":"C:\\\\tmp\\\\x","line":1}]}'), /public_content\[0\]\.file/],
-      ["bad-public-content-commit-ref", Buffer.from('{"schema_version":1,"public_content":[{"rule":"public_content_change_id_trailer","action":"REJECT","file":"commit:notasha","line":1}]}'), /public_content\[0\]\.file/],
-      ["bad-public-content-line", Buffer.from('{"schema_version":1,"public_content":[{"rule":"public_content_semantic_candidate","action":"WARNING","file":"pull_request_metadata","line":"1"}]}'), /public_content\[0\]\.line/],
-      ["zero-public-content-line", Buffer.from('{"schema_version":1,"public_content":[{"rule":"public_content_semantic_candidate","action":"WARNING","file":"pull_request_metadata","line":0}]}'), /public_content\[0\]\.line/],
       ["bad-diagnostic-action", Buffer.from('{"schema_version":1,"diagnostics":[{"rule":"r","action":"BLOCK","file":"x.go","line":1,"message":"m"}]}'), /diagnostics.*action/],
       ["long-message", Buffer.from(JSON.stringify({ schema_version: 1, diagnostics: [{ rule: "r", action: "REJECT", file: "x.go", line: 1, message: "x".repeat(9000) }] })), /too long/],
     ]) {

scripts/semantic-review-workflow.test.sh

@@ -184,10 +184,6 @@ require_in_step "$summary_verify_step" 'eventHeadSha && eventHeadSha.toLowerCase
 require_in_step "$summary_verify_step" 'factsArtifactPattern' "PR quality summary should use the base-bound facts artifact name when available"
 require_in_step "$summary_verify_step" 'const baseSha = artifactBaseSha || eventBaseSha || pr.base.sha' "PR quality summary must prefer the CI-time artifact base SHA"
 require_in_step "$summary_verify_step" 'core.setOutput("artifact_error"' "PR quality summary must expose artifact binding failures"
-require_in_step "$summary_verify_step" 'state: "all"' "PR quality summary fallback must inspect closed PRs before failing"
-require_in_step "$summary_verify_step" 'candidate.state === "open"' "PR quality summary fallback must still prefer open PRs"
-require_in_step "$summary_verify_step" 'workflow_run target PR is no longer open' "PR quality summary must skip stale workflow_run events after PR closure"
-require_in_step "$summary_verify_step" 'pr.state !== "open"' "PR quality summary must skip direct workflow_run PR bindings after PR closure"
 require_in_step "$summary_artifact_step" 'factsArtifactName' "PR quality summary artifact step must use the verified facts artifact binding"
 require_in_step "$summary_extract_facts_step" 'SEMANTIC_REVIEW_DECISION_OUT' "PR quality summary artifact verifier must write an infrastructure decision on verifier failure"
 
@@ -216,12 +212,7 @@ require_in_step "$verify_step" 'runPRs.length > 1' "semantic-review must fail cl
 require_in_step "$verify_step" 'listPullRequestsAssociatedWithCommit' "semantic-review must resolve fork workflow_run PRs when pull_requests is empty"
 require_in_step "$verify_step" 'commit_sha: targetHeadSha' "semantic-review fallback must resolve PRs by the workflow_run PR head SHA"
 require_in_step "$verify_step" 'github.rest.pulls.list' "semantic-review must have a pull-list fallback when commit association is empty"
-require_in_step "$verify_step" 'openCandidatePRs.length > 1' "semantic-review must fail closed when commit-to-PR fallback is ambiguous"
-require_in_step "$verify_step" 'state: "all"' "semantic-review fallback must inspect closed PRs before failing"
-require_in_step "$verify_step" 'candidate.state === "open"' "semantic-review fallback must still prefer open PRs"
-require_in_step "$verify_step" 'workflow_run target PR is no longer open' "semantic-review must skip stale workflow_run events after PR closure"
-require_in_step "$verify_step" 'pr.state !== "open"' "semantic-review must skip direct workflow_run PR bindings after PR closure"
-require_in_step "$verify_step" '!pr.head.repo' "semantic-review must skip unavailable PR head repositories before reading owner/repo"
+require_in_step "$verify_step" 'candidatePRs.length > 1' "semantic-review must fail closed when commit-to-PR fallback is ambiguous"
 require_in_step "$verify_step" 'pr.head.sha !== targetHeadSha' "semantic-review must skip stale PR heads"
 require_in_step "$verify_step" 'eventBaseSha && parsedBaseSha.toLowerCase() !== eventBaseSha.toLowerCase()' "semantic-review should tolerate mutable workflow_run PR base metadata"
 require_in_step "$verify_step" 'const baseSha = artifactBaseSha || eventBaseSha || pr.base.sha' "semantic-review must prefer the CI-time artifact base SHA"
@@ -269,7 +260,6 @@ require_in_step "$semantic_step" 'args+=(--waivers-file' "same-repo PR head waiv
 require_in_step "$precheckout_step" 'SEMANTIC_REVIEW_BASE_SHA' "pre-checkout failure publisher must receive verified base SHA"
 require_in_step "$precheckout_step" 'SEMANTIC_REVIEW_RUN_ID' "pre-checkout failure publisher must receive verified run id"
 require_in_step "$precheckout_step" 'github.rest.pulls.get' "pre-checkout failure publisher must recheck PR target before writing"
-require_in_step "$precheckout_step" 'pull.state !== "open"' "pre-checkout failure publisher must skip closed PRs before writing"
 require_in_step "$precheckout_step" 'pull.head.sha !== headSha' "pre-checkout failure publisher must skip stale PR heads"
 require_in_step "$precheckout_step" 'pull.base.sha !== baseSha' "pre-checkout failure publisher must skip stale PR bases"
 

shortcuts/calendar/calendar_meeting.go

@@ -1,215 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-//
-// calendar +meeting — get meeting info for calendar events via mget_instance_relation_info
-
-package calendar
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"strings"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/output"
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-const meetingLogPrefix = "[calendar +meeting]"
-
-// mgetInstanceRelationRequestBody is the request body for mget_instance_relation_info API.
-type mgetInstanceRelationRequestBody struct {
-	InstanceIDs            []string `json:"instance_ids"`
-	NeedMeetingInstanceIDs bool     `json:"need_meeting_instance_ids"`
-	NeedMeetingNotes       bool     `json:"need_meeting_notes"`
-	NeedAIMeetingNotes     bool     `json:"need_ai_meeting_notes"`
-}
-
-// meetingInfoItem represents a single event's meeting info in the output.
-type meetingInfoItem struct {
-	EventID     string `json:"event_id"`
-	MeetingID   string `json:"meeting_id,omitempty"`
-	MeetingNote string `json:"meeting_note,omitempty"`
-	Error       string `json:"error,omitempty"`
-	Hint        string `json:"hint,omitempty"`
-}
-
-// translateFailMsg converts API fail_msg to a user-friendly error message.
-func translateFailMsg(failMsg string) string {
-	switch failMsg {
-	case "No Permission":
-		return "no read permission for this calendar event (not a participant of the event)"
-	case "Not Found":
-		return "event not found on the specified calendar (event ID may be incorrect or does not belong to this calendar)"
-	default:
-		return failMsg
-	}
-}
-
-// fetchEventMeetingInfo queries mget_instance_relation_info for a single event instance.
-func fetchEventMeetingInfo(ctx context.Context, runtime *common.RuntimeContext, instanceID, calendarID string) *meetingInfoItem {
-	body := &mgetInstanceRelationRequestBody{
-		InstanceIDs:            []string{instanceID},
-		NeedMeetingInstanceIDs: true,
-		NeedMeetingNotes:       true,
-		NeedAIMeetingNotes:     false,
-	}
-
-	data, err := runtime.CallAPITyped("POST",
-		fmt.Sprintf("/open-apis/calendar/v4/calendars/%s/events/mget_instance_relation_info", validate.EncodePathSegment(calendarID)),
-		nil, body)
-	if err != nil {
-		msg := unwrapCalendarAPIError(err)
-		if msg == "" {
-			msg = err.Error()
-		}
-		return &meetingInfoItem{EventID: instanceID, Error: msg}
-	}
-
-	// Check for failed instance IDs first
-	if failedIDs, _ := data["failed_instance_ids"].([]any); len(failedIDs) > 0 {
-		for _, raw := range failedIDs {
-			if failInfo, ok := raw.(map[string]any); ok {
-				if failID, _ := failInfo["instance_id"].(string); failID == instanceID {
-					failMsg, _ := failInfo["fail_msg"].(string)
-					return &meetingInfoItem{EventID: instanceID, Error: translateFailMsg(failMsg)}
-				}
-			}
-		}
-	}
-
-	infos, _ := data["instance_relation_infos"].([]any)
-	if len(infos) == 0 {
-		return &meetingInfoItem{EventID: instanceID, Error: "no event relation info found"}
-	}
-
-	info, _ := infos[0].(map[string]any)
-	result := &meetingInfoItem{EventID: instanceID}
-
-	// Extract meeting_id (return first if multiple) — API returns string
-	if rawIDs, _ := info["meeting_instance_ids"].([]any); len(rawIDs) > 0 {
-		if id, ok := rawIDs[0].(string); ok && id != "" {
-			result.MeetingID = id
-		}
-	}
-
-	// Extract meeting_note (return first if multiple)
-	if notes, _ := info["meeting_notes"].([]any); len(notes) > 0 {
-		if note, ok := notes[0].(string); ok && note != "" {
-			result.MeetingNote = note
-		}
-	}
-
-	// Add hints for empty resources (independent checks)
-	var emptyFields []string
-	if result.MeetingID == "" {
-		emptyFields = append(emptyFields, "meeting_id")
-	}
-	if result.MeetingNote == "" {
-		emptyFields = append(emptyFields, "meeting_note")
-	}
-	if len(emptyFields) > 0 {
-		result.Hint = fmt.Sprintf("%s not found for this event", strings.Join(emptyFields, ", "))
-	}
-
-	return result
-}
-
-// CalendarMeeting gets meeting info for calendar events.
-var CalendarMeeting = common.Shortcut{
-	Service:     "calendar",
-	Command:     "+meeting",
-	Description: "Get meeting info for calendar events (meeting_id, meeting_note)",
-	Risk:        "read",
-	Scopes:      []string{"calendar:calendar.event:read"},
-	AuthTypes:   []string{"user"},
-	HasFormat:   true,
-	Flags: []common.Flag{
-		{Name: "event-ids", Desc: "calendar event instance IDs, comma-separated for batch", Required: true},
-		{Name: "calendar-id", Desc: "calendar ID (default: primary)"},
-	},
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		if err := rejectCalendarAutoBotFallback(runtime); err != nil {
-			return err
-		}
-		ids := common.SplitCSV(runtime.Str("event-ids"))
-		const maxBatchSize = 50
-		if len(ids) > maxBatchSize {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--event-ids: too many IDs (%d), maximum is %d", len(ids), maxBatchSize).WithParam("--event-ids")
-		}
-		return nil
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		calendarID := runtime.Str("calendar-id")
-		if calendarID == "" {
-			calendarID = "<primary>"
-		}
-		return common.NewDryRunAPI().
-			POST(fmt.Sprintf("/open-apis/calendar/v4/calendars/%s/events/mget_instance_relation_info", calendarID)).
-			Set("event_ids", common.SplitCSV(runtime.Str("event-ids"))).
-			Set("calendar_id", calendarID)
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		errOut := runtime.IO().ErrOut
-		instanceIDs := common.SplitCSV(runtime.Str("event-ids"))
-		calendarID := strings.TrimSpace(runtime.Str("calendar-id"))
-		if calendarID == "" {
-			calendarID = PrimaryCalendarIDStr
-		}
-
-		results := make([]*meetingInfoItem, 0, len(instanceIDs))
-		fmt.Fprintf(errOut, "%s querying %d event_id(s)\n", meetingLogPrefix, len(instanceIDs))
-		for _, id := range instanceIDs {
-			if err := ctx.Err(); err != nil {
-				return err
-			}
-			fmt.Fprintf(errOut, "%s querying event_id=%s ...\n", meetingLogPrefix, id)
-			results = append(results, fetchEventMeetingInfo(ctx, runtime, id, calendarID))
-		}
-
-		successCount := 0
-		for _, r := range results {
-			if r.Error == "" {
-				successCount++
-			}
-		}
-		fmt.Fprintf(errOut, "%s done: %d total, %d succeeded, %d failed\n", meetingLogPrefix, len(results), successCount, len(results)-successCount)
-
-		if successCount == 0 && len(results) > 0 {
-			return runtime.OutPartialFailure(map[string]any{"meetings": results}, &output.Meta{Count: len(results)})
-		}
-
-		outData := map[string]any{"meetings": results}
-		runtime.OutFormat(outData, &output.Meta{Count: len(results)}, func(w io.Writer) {
-			if len(results) == 0 {
-				fmt.Fprintln(w, "No events.")
-				return
-			}
-			var rows []map[string]interface{}
-			for _, r := range results {
-				row := map[string]interface{}{"event_id": r.EventID}
-				if r.Error != "" {
-					row["status"] = "FAIL"
-					row["error"] = r.Error
-				} else {
-					row["status"] = "OK"
-					if r.MeetingID != "" {
-						row["meeting_id"] = r.MeetingID
-					}
-					if r.MeetingNote != "" {
-						row["meeting_note"] = r.MeetingNote
-					}
-					if r.Hint != "" {
-						row["hint"] = r.Hint
-					}
-				}
-				rows = append(rows, row)
-			}
-			output.PrintTable(w, rows)
-			fmt.Fprintf(w, "\n%d event(s), %d succeeded, %d failed\n", len(results), successCount, len(results)-successCount)
-		})
-		return nil
-	},
-}

shortcuts/calendar/calendar_meeting_test.go

@@ -1,484 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package calendar
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"strings"
-	"sync"
-	"testing"
-
-	"github.com/spf13/cobra"
-
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/httpmock"
-	"github.com/larksuite/cli/internal/output"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// ---------------------------------------------------------------------------
-// helpers
-// ---------------------------------------------------------------------------
-
-var calWarmOnce sync.Once
-
-func calWarmTokenCache(t *testing.T) {
-	t.Helper()
-	calWarmOnce.Do(func() {
-		f, _, _, reg := cmdutil.TestFactory(t, calDefaultConfig())
-		reg.Register(&httpmock.Stub{
-			URL:  "/open-apis/test/v1/warm",
-			Body: map[string]interface{}{"code": 0, "msg": "ok", "data": map[string]interface{}{}},
-		})
-		s := common.Shortcut{
-			Service:   "test",
-			Command:   "+warm",
-			AuthTypes: []string{"bot"},
-			Execute: func(_ context.Context, rctx *common.RuntimeContext) error {
-				_, err := rctx.CallAPITyped("GET", "/open-apis/test/v1/warm", nil, nil)
-				return err
-			},
-		}
-		parent := &cobra.Command{Use: "test"}
-		s.Mount(parent, f)
-		parent.SetArgs([]string{"+warm"})
-		parent.SilenceErrors = true
-		parent.SilenceUsage = true
-		parent.Execute()
-	})
-}
-
-func calDefaultConfig() *core.CliConfig {
-	return &core.CliConfig{
-		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
-		UserOpenId: "ou_testuser",
-	}
-}
-
-func calMountAndRun(t *testing.T, s common.Shortcut, args []string, f *cmdutil.Factory, stdout *bytes.Buffer) error {
-	t.Helper()
-	calWarmTokenCache(t)
-	parent := &cobra.Command{Use: "calendar"}
-	s.Mount(parent, f)
-	parent.SetArgs(args)
-	parent.SilenceErrors = true
-	parent.SilenceUsage = true
-	if stdout != nil {
-		stdout.Reset()
-	}
-	return parent.Execute()
-}
-
-// ---------------------------------------------------------------------------
-// calendar +meeting tests
-// ---------------------------------------------------------------------------
-
-func mgetInstanceRelationStub(calendarID, instanceID string, meetingIDs []string, meetingNotes []string, aiMeetingNotes []string) *httpmock.Stub {
-	infos := map[string]interface{}{
-		"instance_id": instanceID,
-	}
-	mIDs := make([]interface{}, len(meetingIDs))
-	for i, id := range meetingIDs {
-		mIDs[i] = id
-	}
-	infos["meeting_instance_ids"] = mIDs
-	if len(meetingNotes) > 0 {
-		notes := make([]interface{}, len(meetingNotes))
-		for i, n := range meetingNotes {
-			notes[i] = n
-		}
-		infos["meeting_notes"] = notes
-	}
-	if len(aiMeetingNotes) > 0 {
-		notes := make([]interface{}, len(aiMeetingNotes))
-		for i, n := range aiMeetingNotes {
-			notes[i] = n
-		}
-		infos["ai_meeting_notes"] = notes
-	}
-	return &httpmock.Stub{
-		Method: "POST",
-		URL:    fmt.Sprintf("/open-apis/calendar/v4/calendars/%s/events/mget_instance_relation_info", calendarID),
-		Body: map[string]interface{}{
-			"code": 0, "msg": "ok",
-			"data": map[string]interface{}{
-				"instance_relation_infos": []interface{}{infos},
-			},
-		},
-	}
-}
-
-func mgetInstanceRelationFailedStub(calendarID, instanceID, failMsg string) *httpmock.Stub {
-	return &httpmock.Stub{
-		Method: "POST",
-		URL:    fmt.Sprintf("/open-apis/calendar/v4/calendars/%s/events/mget_instance_relation_info", calendarID),
-		Body: map[string]interface{}{
-			"code": 0, "msg": "ok",
-			"data": map[string]interface{}{
-				"instance_relation_infos": []interface{}{},
-				"failed_instance_ids": []interface{}{
-					map[string]interface{}{
-						"instance_id": instanceID,
-						"fail_msg":    failMsg,
-					},
-				},
-			},
-		},
-	}
-}
-
-func TestMeeting_Validation_MissingEventIDs(t *testing.T) {
-	f, _, _, _ := cmdutil.TestFactory(t, calDefaultConfig())
-	err := calMountAndRun(t, CalendarMeeting, []string{"+meeting", "--as", "user"}, f, nil)
-	if err == nil {
-		t.Fatal("expected validation error for missing --event-ids")
-	}
-}
-
-func TestMeeting_Validation_BatchLimit(t *testing.T) {
-	f, _, _, _ := cmdutil.TestFactory(t, calDefaultConfig())
-	ids := make([]string, 51)
-	for i := range ids {
-		ids[i] = fmt.Sprintf("evt%d", i)
-	}
-	err := calMountAndRun(t, CalendarMeeting, []string{"+meeting", "--event-ids", strings.Join(ids, ","), "--as", "user"}, f, nil)
-	if err == nil {
-		t.Fatal("expected batch limit error")
-	}
-	if !strings.Contains(err.Error(), "too many IDs") {
-		t.Errorf("expected 'too many IDs' error, got: %v", err)
-	}
-}
-
-func TestMeeting_DryRun(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, calDefaultConfig())
-	err := calMountAndRun(t, CalendarMeeting, []string{"+meeting", "--event-ids", "evt001", "--dry-run", "--as", "user"}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !strings.Contains(stdout.String(), "mget_instance_relation_info") {
-		t.Errorf("dry-run should show mget API path, got: %s", stdout.String())
-	}
-}
-
-func TestMeeting_Execute_Success(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, calDefaultConfig())
-	reg.Register(mgetInstanceRelationStub("primary", "evt_m1", []string{"123456"}, []string{"doc_note1"}, []string{"doc_ai1"}))
-
-	err := calMountAndRun(t, CalendarMeeting, []string{"+meeting", "--event-ids", "evt_m1", "--as", "user"}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	var resp map[string]any
-	if err := json.Unmarshal(stdout.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to parse output: %v", err)
-	}
-	data, _ := resp["data"].(map[string]any)
-	meetings, _ := data["meetings"].([]any)
-	if len(meetings) != 1 {
-		t.Fatalf("expected 1 meeting, got %d", len(meetings))
-	}
-	m, _ := meetings[0].(map[string]any)
-	if m["meeting_id"] != "123456" {
-		t.Errorf("meeting_id = %v, want 123456", m["meeting_id"])
-	}
-	if m["meeting_note"] != "doc_note1" {
-		t.Errorf("meeting_note = %v, want doc_note1", m["meeting_note"])
-	}
-	if _, hasAI := m["ai_meeting_note"]; hasAI {
-		t.Error("ai_meeting_note should not be present in output")
-	}
-}
-
-func TestMeeting_Execute_FailedInstance(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, calDefaultConfig())
-	reg.Register(mgetInstanceRelationFailedStub("primary", "evt_fail", "No Permission"))
-
-	err := calMountAndRun(t, CalendarMeeting, []string{"+meeting", "--event-ids", "evt_fail", "--as", "user"}, f, stdout)
-	if err == nil {
-		t.Fatal("expected partial failure error")
-	}
-	var pfErr *output.PartialFailureError
-	if !errors.As(err, &pfErr) {
-		t.Fatalf("expected *output.PartialFailureError, got %T: %v", err, err)
-	}
-	// Verify translated fail_msg appears in output
-	var resp map[string]any
-	if err := json.Unmarshal(stdout.Bytes(), &resp); err == nil {
-		data, _ := resp["data"].(map[string]any)
-		meetings, _ := data["meetings"].([]any)
-		if len(meetings) > 0 {
-			m, _ := meetings[0].(map[string]any)
-			if errMsg, _ := m["error"].(string); !strings.Contains(errMsg, "no read permission") {
-				t.Errorf("expected translated fail_msg, got: %v", errMsg)
-			}
-		}
-	}
-}
-
-func TestMeeting_Execute_NoMeeting(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, calDefaultConfig())
-	reg.Register(mgetInstanceRelationStub("primary", "evt_nomeet", []string{}, nil, nil))
-
-	err := calMountAndRun(t, CalendarMeeting, []string{"+meeting", "--event-ids", "evt_nomeet", "--as", "user"}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	var resp map[string]any
-	if err := json.Unmarshal(stdout.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to parse output: %v", err)
-	}
-	data, _ := resp["data"].(map[string]any)
-	meetings, _ := data["meetings"].([]any)
-	if len(meetings) != 1 {
-		t.Fatalf("expected 1 meeting, got %d", len(meetings))
-	}
-	m, _ := meetings[0].(map[string]any)
-	if hint, _ := m["hint"].(string); !strings.Contains(hint, "meeting_id") {
-		t.Errorf("expected hint about meeting_id, got: %v", hint)
-	}
-}
-
-// ---------------------------------------------------------------------------
-// calendar +search-event tests
-// ---------------------------------------------------------------------------
-
-func TestSearchEvent_Validation_InvalidTimeRange(t *testing.T) {
-	f, _, _, _ := cmdutil.TestFactory(t, calDefaultConfig())
-	err := calMountAndRun(t, CalendarSearchEvent, []string{"+search-event", "--start", "bad-format", "--end", "2026-04-27", "--as", "user"}, f, nil)
-	if err == nil {
-		t.Fatal("expected validation error for invalid --start")
-	}
-	if !strings.Contains(err.Error(), "--start") {
-		t.Errorf("unexpected error: %v", err)
-	}
-}
-
-func TestSearchEvent_Validation_TimeRangeStartAfterEnd(t *testing.T) {
-	f, _, _, _ := cmdutil.TestFactory(t, calDefaultConfig())
-	err := calMountAndRun(t, CalendarSearchEvent, []string{"+search-event", "--start", "2026-04-27", "--end", "2026-04-20", "--as", "user"}, f, nil)
-	if err == nil {
-		t.Fatal("expected validation error for start after end")
-	}
-}
-
-func TestSearchEvent_DryRun(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, calDefaultConfig())
-	err := calMountAndRun(t, CalendarSearchEvent, []string{"+search-event", "--query", "周会", "--dry-run", "--as", "user"}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !strings.Contains(stdout.String(), "search_event") {
-		t.Errorf("dry-run should show search_event API path, got: %s", stdout.String())
-	}
-}
-
-func TestSearchEvent_Execute_Success(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, calDefaultConfig())
-	reg.Register(&httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/calendar/v4/calendars/primary/events/search_event",
-		Body: map[string]interface{}{
-			"code": 0, "msg": "ok",
-			"data": map[string]interface{}{
-				"items": []interface{}{
-					map[string]interface{}{
-						"display_info": "Q2 周会\n2026-04-23 15:00-16:00",
-						"meta_data": map[string]interface{}{
-							"event_id": "evt_search1",
-							"summary":  "Q2 周会",
-							"start": map[string]interface{}{
-								"date_time": "2026-04-23T15:00:00+08:00",
-								"timezone":  "Asia/Shanghai",
-							},
-							"end": map[string]interface{}{
-								"date_time": "2026-04-23T16:00:00+08:00",
-								"timezone":  "Asia/Shanghai",
-							},
-							"is_all_day": false,
-							"app_link":   "https://applink.feishu.cn/...",
-						},
-					},
-				},
-				"has_more":   false,
-				"page_token": "",
-			},
-		},
-	})
-
-	err := calMountAndRun(t, CalendarSearchEvent, []string{"+search-event", "--query", "周会", "--as", "user"}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	var resp map[string]any
-	if err := json.Unmarshal(stdout.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to parse output: %v", err)
-	}
-	data, _ := resp["data"].(map[string]any)
-	if data["calendar_id"] != "primary" {
-		t.Errorf("calendar_id = %v, want primary", data["calendar_id"])
-	}
-	items, _ := data["items"].([]any)
-	if len(items) != 1 {
-		t.Fatalf("expected 1 item, got %d", len(items))
-	}
-	item, _ := items[0].(map[string]any)
-	if item["event_id"] != "evt_search1" {
-		t.Errorf("event_id = %v, want evt_search1", item["event_id"])
-	}
-	if item["summary"] != "Q2 周会" {
-		t.Errorf("summary = %v, want 'Q2 周会'", item["summary"])
-	}
-}
-
-func TestSearchEvent_Execute_Empty(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, calDefaultConfig())
-	reg.Register(&httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/calendar/v4/calendars/primary/events/search_event",
-		Body: map[string]interface{}{
-			"code": 0, "msg": "ok",
-			"data": map[string]interface{}{
-				"items":    []interface{}{},
-				"has_more": false,
-			},
-		},
-	})
-
-	err := calMountAndRun(t, CalendarSearchEvent, []string{"+search-event", "--query", "nonexistent", "--as", "user"}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Pure function tests
-// ---------------------------------------------------------------------------
-
-func TestParseSearchEventTimeRange(t *testing.T) {
-	tests := []struct {
-		name    string
-		start   string
-		end     string
-		wantErr bool
-	}{
-		{"empty", "", "", false},
-		{"valid", "2026-04-20", "2026-04-27", false},
-		{"start only defaults end", "2026-04-20", "", false},
-		{"end only defaults start", "", "2026-04-27", false},
-		{"invalid start format", "not-a-date", "2026-04-27", true},
-		{"start after end", "2026-04-27", "2026-04-20", true},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			cmd := &cobra.Command{Use: "test"}
-			cmd.Flags().String("start", "", "")
-			cmd.Flags().String("end", "", "")
-			if tt.start != "" {
-				_ = cmd.Flags().Set("start", tt.start)
-			}
-			if tt.end != "" {
-				_ = cmd.Flags().Set("end", tt.end)
-			}
-			runtime := common.TestNewRuntimeContext(cmd, calDefaultConfig())
-			_, _, err := parseSearchEventTimeRange(runtime)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("parseSearchEventTimeRange() error = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
-	}
-
-	t.Run("start only fills end with end-of-day", func(t *testing.T) {
-		cmd := &cobra.Command{Use: "test"}
-		cmd.Flags().String("start", "", "")
-		cmd.Flags().String("end", "", "")
-		_ = cmd.Flags().Set("start", "2026-04-20")
-		runtime := common.TestNewRuntimeContext(cmd, calDefaultConfig())
-		startRFC, endRFC, err := parseSearchEventTimeRange(runtime)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if !strings.HasPrefix(startRFC, "2026-04-20T00:00:00") {
-			t.Errorf("start = %s, want 2026-04-20T00:00:00...", startRFC)
-		}
-		if !strings.HasPrefix(endRFC, "2026-04-20T23:59:59") {
-			t.Errorf("end = %s, want 2026-04-20T23:59:59...", endRFC)
-		}
-	})
-
-	t.Run("end only fills start with start-of-day", func(t *testing.T) {
-		cmd := &cobra.Command{Use: "test"}
-		cmd.Flags().String("start", "", "")
-		cmd.Flags().String("end", "", "")
-		_ = cmd.Flags().Set("end", "2026-04-27")
-		runtime := common.TestNewRuntimeContext(cmd, calDefaultConfig())
-		startRFC, endRFC, err := parseSearchEventTimeRange(runtime)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if !strings.HasPrefix(startRFC, "2026-04-27T00:00:00") {
-			t.Errorf("start = %s, want 2026-04-27T00:00:00...", startRFC)
-		}
-		if !strings.HasPrefix(endRFC, "2026-04-27T23:59:59") {
-			t.Errorf("end = %s, want 2026-04-27T23:59:59...", endRFC)
-		}
-	})
-}
-
-func TestBuildSearchEventFilter(t *testing.T) {
-	cmd := &cobra.Command{Use: "test"}
-	cmd.Flags().String("attendee-ids", "", "")
-	_ = cmd.Flags().Set("attendee-ids", "ou_user1,oc_chat1,omm_room1")
-	runtime := common.TestNewRuntimeContext(cmd, calDefaultConfig())
-
-	filter := buildSearchEventFilter(runtime, "", "")
-	if filter == nil {
-		t.Fatal("expected filter to be non-nil")
-	}
-	if len(filter.AttendeeUserIDs) != 1 || filter.AttendeeUserIDs[0] != "ou_user1" {
-		t.Errorf("attendee_user_ids = %v, want [ou_user1]", filter.AttendeeUserIDs)
-	}
-	if len(filter.AttendeeChatIDs) != 1 || filter.AttendeeChatIDs[0] != "oc_chat1" {
-		t.Errorf("attendee_chat_ids = %v, want [oc_chat1]", filter.AttendeeChatIDs)
-	}
-	if len(filter.MeetingRoomIDs) != 1 || filter.MeetingRoomIDs[0] != "omm_room1" {
-		t.Errorf("meeting_room_ids = %v, want [omm_room1]", filter.MeetingRoomIDs)
-	}
-}
-
-func TestBuildSearchEventFilter_Empty(t *testing.T) {
-	cmd := &cobra.Command{Use: "test"}
-	cmd.Flags().String("attendee-ids", "", "")
-	runtime := common.TestNewRuntimeContext(cmd, calDefaultConfig())
-
-	filter := buildSearchEventFilter(runtime, "", "")
-	if filter != nil {
-		t.Errorf("expected nil for empty filter, got %v", filter)
-	}
-}
-
-func TestBuildSearchEventFilter_TimeRange(t *testing.T) {
-	cmd := &cobra.Command{Use: "test"}
-	cmd.Flags().String("attendee-ids", "", "")
-	runtime := common.TestNewRuntimeContext(cmd, calDefaultConfig())
-
-	filter := buildSearchEventFilter(runtime, "2026-04-20T00:00:00+08:00", "2026-04-27T23:59:59+08:00")
-	if filter == nil {
-		t.Fatal("expected filter to be non-nil")
-	}
-	if filter.TimeRange == nil {
-		t.Fatal("expected time_range in filter")
-	}
-	if filter.TimeRange.StartTime != "2026-04-20T00:00:00+08:00" {
-		t.Errorf("start_time = %v, want 2026-04-20T00:00:00+08:00", filter.TimeRange.StartTime)
-	}
-}

shortcuts/calendar/calendar_room_find.go

@@ -66,8 +66,7 @@ type roomFindSlot struct {
 type roomFindTimeSlot struct {
 	Start        string                `json:"start,omitempty"`
 	End          string                `json:"end,omitempty"`
-	MeetingRooms []*roomFindSuggestion `json:"meeting_rooms"`
-	Hint         string                `json:"hint,omitempty"`
+	MeetingRooms []*roomFindSuggestion `json:"meeting_rooms,omitempty"`
 }
 
 type roomFindOutput struct {
@@ -104,18 +103,11 @@ func collectRoomFindResults(slots []roomFindSlot, limit int, fetch func(roomFind
 				}
 				return
 			}
-			if suggestions == nil {
-				suggestions = []*roomFindSuggestion{}
-			}
-			ts := &roomFindTimeSlot{
+			out.TimeSlots = append(out.TimeSlots, &roomFindTimeSlot{
 				Start:        slot.Start,
 				End:          slot.End,
 				MeetingRooms: suggestions,
-			}
-			if len(suggestions) == 0 {
-				ts.Hint = "no meeting room matches the current filters for this slot"
-			}
-			out.TimeSlots = append(out.TimeSlots, ts)
+			})
 		}(slot)
 	}
 	wg.Wait()
@@ -382,10 +374,6 @@ var CalendarRoomFind = common.Shortcut{
 			}
 			for _, slot := range out.TimeSlots {
 				fmt.Fprintf(w, "%s - %s\n", slot.Start, slot.End)
-				if len(slot.MeetingRooms) == 0 {
-					fmt.Fprintf(w, "0 meeting room(s) found: %s\n", slot.Hint)
-					continue
-				}
 				var rows []map[string]interface{}
 				for _, room := range slot.MeetingRooms {
 					rows = append(rows, map[string]interface{}{
@@ -396,7 +384,6 @@ var CalendarRoomFind = common.Shortcut{
 					})
 				}
 				output.PrintTable(w, rows)
-				fmt.Fprintf(w, "%d meeting room(s) found\n", len(slot.MeetingRooms))
 				fmt.Fprintln(w)
 			}
 		})

shortcuts/calendar/calendar_room_find_test.go

@@ -4,8 +4,6 @@
 package calendar
 
 import (
-	"encoding/json"
-	"strings"
 	"testing"
 	"time"
 )
@@ -84,60 +82,3 @@ func TestCollectRoomFindResults_LimitsConcurrency(t *testing.T) {
 		t.Fatalf("expected %d time slots, got %d", len(slots), len(out.TimeSlots))
 	}
 }
-
-func TestCollectRoomFindResults_EmptySlotEmitsHintAndArray(t *testing.T) {
-	slots := []roomFindSlot{
-		{Start: "2026-03-27T14:00:00+08:00", End: "2026-03-27T15:00:00+08:00"},
-		{Start: "2026-03-27T15:00:00+08:00", End: "2026-03-27T16:00:00+08:00"},
-	}
-
-	out, err := collectRoomFindResults(slots, 2, func(slot roomFindSlot) ([]*roomFindSuggestion, error) {
-		if strings.HasPrefix(slot.Start, "2026-03-27T14") {
-			return []*roomFindSuggestion{{RoomID: "rm_1", RoomName: "Room A"}}, nil
-		}
-		return nil, nil
-	})
-	if err != nil {
-		t.Fatalf("collectRoomFindResults returned error: %v", err)
-	}
-	if len(out.TimeSlots) != 2 {
-		t.Fatalf("expected 2 time slots, got %d", len(out.TimeSlots))
-	}
-
-	for _, ts := range out.TimeSlots {
-		if ts.MeetingRooms == nil {
-			t.Fatalf("meeting_rooms should be non-nil for slot %s", ts.Start)
-		}
-		switch {
-		case strings.HasPrefix(ts.Start, "2026-03-27T14"):
-			if len(ts.MeetingRooms) != 1 {
-				t.Fatalf("expected 1 room for first slot, got %d", len(ts.MeetingRooms))
-			}
-			if ts.Hint != "" {
-				t.Fatalf("non-empty slot should not carry hint, got %q", ts.Hint)
-			}
-		case strings.HasPrefix(ts.Start, "2026-03-27T15"):
-			if len(ts.MeetingRooms) != 0 {
-				t.Fatalf("expected 0 rooms for empty slot, got %d", len(ts.MeetingRooms))
-			}
-			if ts.Hint == "" {
-				t.Fatal("empty slot should carry a hint explaining the filters")
-			}
-		}
-	}
-
-	emptySlot := out.TimeSlots[0]
-	if !strings.HasPrefix(emptySlot.Start, "2026-03-27T15") {
-		emptySlot = out.TimeSlots[1]
-	}
-	raw, err := json.Marshal(emptySlot)
-	if err != nil {
-		t.Fatalf("marshal empty slot: %v", err)
-	}
-	if !strings.Contains(string(raw), `"meeting_rooms":[]`) {
-		t.Fatalf("expected meeting_rooms:[] in JSON, got %s", raw)
-	}
-	if !strings.Contains(string(raw), `"hint"`) {
-		t.Fatalf("expected hint field in JSON, got %s", raw)
-	}
-}

shortcuts/calendar/calendar_search_event.go

@@ -1,331 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-//
-// calendar +search-event — search calendar events by keyword, time range, and attendees
-
-package calendar
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/output"
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-const (
-	defaultSearchEventPageSize = 20
-	maxSearchEventPageSize     = 30
-)
-
-// searchEventTimeRange represents the time range filter for search_event API.
-type searchEventTimeRange struct {
-	StartTime string `json:"start_time,omitempty"`
-	EndTime   string `json:"end_time,omitempty"`
-}
-
-// searchEventFilter represents the filter object for the search_event API request.
-type searchEventFilter struct {
-	AttendeeUserIDs []string              `json:"attendee_user_ids,omitempty"`
-	AttendeeChatIDs []string              `json:"attendee_chat_ids,omitempty"`
-	MeetingRoomIDs  []string              `json:"meeting_room_ids,omitempty"`
-	TimeRange       *searchEventTimeRange `json:"time_range,omitempty"`
-}
-
-// searchEventRequestBody is the request body for the search_event API.
-type searchEventRequestBody struct {
-	Query  string             `json:"query"`
-	Filter *searchEventFilter `json:"filter,omitempty"`
-}
-
-// searchEventTimeInfo represents start/end time info in the search result.
-type searchEventTimeInfo struct {
-	Date     string `json:"date,omitempty"`
-	DateTime string `json:"date_time,omitempty"`
-	Timezone string `json:"timezone,omitempty"`
-}
-
-// searchEventItem represents a single event in the search result output.
-type searchEventItem struct {
-	EventID  string               `json:"event_id"`
-	Summary  string               `json:"summary"`
-	Start    *searchEventTimeInfo `json:"start,omitempty"`
-	End      *searchEventTimeInfo `json:"end,omitempty"`
-	IsAllDay bool                 `json:"is_all_day,omitempty"`
-	AppLink  string               `json:"app_link,omitempty"`
-}
-
-// searchEventOutput is the structured output for +search-event.
-type searchEventOutput struct {
-	CalendarID string            `json:"calendar_id"`
-	Items      []searchEventItem `json:"items"`
-	HasMore    bool              `json:"has_more"`
-	PageToken  string            `json:"page_token"`
-}
-
-// parseSearchEventTimeRange parses --start / --end into RFC3339 strings.
-// When only one side is provided, the other defaults to the same day's
-// boundary (start → end-of-day, end → start-of-day).
-func parseSearchEventTimeRange(runtime *common.RuntimeContext) (string, string, error) {
-	startInput := strings.TrimSpace(runtime.Str("start"))
-	endInput := strings.TrimSpace(runtime.Str("end"))
-	if startInput == "" && endInput == "" {
-		return "", "", nil
-	}
-
-	var startSec, endSec int64
-
-	if startInput != "" {
-		ts, err := common.ParseTime(startInput)
-		if err != nil {
-			return "", "", errs.NewValidationError(errs.SubtypeInvalidArgument, "--start: %v", err).WithParam("--start")
-		}
-		startSec, _ = strconv.ParseInt(ts, 10, 64)
-	}
-	if endInput != "" {
-		ts, err := common.ParseTime(endInput, "end")
-		if err != nil {
-			return "", "", errs.NewValidationError(errs.SubtypeInvalidArgument, "--end: %v", err).WithParam("--end")
-		}
-		endSec, _ = strconv.ParseInt(ts, 10, 64)
-	}
-
-	if startInput == "" {
-		t := time.Unix(endSec, 0).In(time.Local)
-		startSec = time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, t.Location()).Unix()
-	}
-	if endInput == "" {
-		t := time.Unix(startSec, 0).In(time.Local)
-		endSec = time.Date(t.Year(), t.Month(), t.Day(), 23, 59, 59, 0, t.Location()).Unix()
-	}
-
-	if startSec > endSec {
-		return "", "", errs.NewValidationError(errs.SubtypeInvalidArgument, "--start must be before --end").WithParam("--start")
-	}
-
-	return time.Unix(startSec, 0).Format(time.RFC3339), time.Unix(endSec, 0).Format(time.RFC3339), nil
-}
-
-// buildSearchEventFilter builds the filter object for the search_event API.
-func buildSearchEventFilter(runtime *common.RuntimeContext, startTime, endTime string) *searchEventFilter {
-	attendeeIDs := common.SplitCSV(runtime.Str("attendee-ids"))
-
-	var userIDs, chatIDs, roomIDs []string
-	for _, id := range attendeeIDs {
-		switch {
-		case strings.HasPrefix(id, "ou_"):
-			userIDs = append(userIDs, id)
-		case strings.HasPrefix(id, "oc_"):
-			chatIDs = append(chatIDs, id)
-		case strings.HasPrefix(id, "omm_"):
-			roomIDs = append(roomIDs, id)
-		default:
-			userIDs = append(userIDs, id)
-		}
-	}
-
-	var tr *searchEventTimeRange
-	if startTime != "" || endTime != "" {
-		tr = &searchEventTimeRange{StartTime: startTime, EndTime: endTime}
-	}
-
-	if len(userIDs) == 0 && len(chatIDs) == 0 && len(roomIDs) == 0 && tr == nil {
-		return nil
-	}
-	return &searchEventFilter{
-		AttendeeUserIDs: userIDs,
-		AttendeeChatIDs: chatIDs,
-		MeetingRoomIDs:  roomIDs,
-		TimeRange:       tr,
-	}
-}
-
-// extractTimeInfo extracts time info from a meta_data start/end map.
-func extractTimeInfo(m map[string]any) *searchEventTimeInfo {
-	if m == nil {
-		return nil
-	}
-	info := &searchEventTimeInfo{}
-	if v, ok := m["date"].(string); ok && v != "" {
-		info.Date = v
-	}
-	if v, ok := m["date_time"].(string); ok && v != "" {
-		info.DateTime = v
-	}
-	if v, ok := m["timezone"].(string); ok && v != "" {
-		info.Timezone = v
-	}
-	if info.Date == "" && info.DateTime == "" {
-		return nil
-	}
-	return info
-}
-
-// CalendarSearchEvent searches calendar events by keyword, time range, and attendees.
-var CalendarSearchEvent = common.Shortcut{
-	Service:     "calendar",
-	Command:     "+search-event",
-	Description: "Search calendar events by keyword, time range, and attendees",
-	Risk:        "read",
-	Scopes:      []string{"calendar:calendar.event:read"},
-	AuthTypes:   []string{"user"},
-	HasFormat:   true,
-	Flags: []common.Flag{
-		{Name: "calendar-id", Desc: "calendar ID (default: primary)"},
-		{Name: "query", Desc: "search keyword"},
-		{Name: "attendee-ids", Desc: "attendee IDs, comma-separated (supports user ou_, chat oc_, room omm_)"},
-		{Name: "start", Desc: "search time range start (ISO 8601 or YYYY-MM-DD)"},
-		{Name: "end", Desc: "search time range end (ISO 8601 or YYYY-MM-DD)"},
-		{Name: "page-token", Desc: "page token for next page"},
-		{Name: "page-size", Default: "20", Desc: "page size, 1-30 (default 20)"},
-	},
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		if err := rejectCalendarAutoBotFallback(runtime); err != nil {
-			return err
-		}
-		if _, _, err := parseSearchEventTimeRange(runtime); err != nil {
-			return err
-		}
-		if _, err := common.ValidatePageSizeTyped(runtime, "page-size", defaultSearchEventPageSize, 1, maxSearchEventPageSize); err != nil {
-			return err
-		}
-		return nil
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		calendarID := runtime.Str("calendar-id")
-		if calendarID == "" {
-			calendarID = "<primary>"
-		}
-		return common.NewDryRunAPI().
-			POST(fmt.Sprintf("/open-apis/calendar/v4/calendars/%s/events/search_event", calendarID)).
-			Set("calendar_id", calendarID)
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		calendarID := strings.TrimSpace(runtime.Str("calendar-id"))
-		if calendarID == "" {
-			calendarID = PrimaryCalendarIDStr
-		}
-
-		startTime, endTime, err := parseSearchEventTimeRange(runtime)
-		if err != nil {
-			return err
-		}
-
-		// Build request body — always send query (even if empty)
-		body := &searchEventRequestBody{
-			Query: strings.TrimSpace(runtime.Str("query")),
-		}
-		if filter := buildSearchEventFilter(runtime, startTime, endTime); filter != nil {
-			body.Filter = filter
-		}
-
-		// Build query params
-		params := map[string]any{}
-		pageSize, _ := strconv.Atoi(strings.TrimSpace(runtime.Str("page-size")))
-		if pageSize <= 0 {
-			pageSize = defaultSearchEventPageSize
-		}
-		params["page_size"] = strconv.Itoa(pageSize)
-		if pt := strings.TrimSpace(runtime.Str("page-token")); pt != "" {
-			params["page_token"] = pt
-		}
-
-		data, err := runtime.CallAPITyped("POST",
-			fmt.Sprintf("/open-apis/calendar/v4/calendars/%s/events/search_event", validate.EncodePathSegment(calendarID)),
-			params, body)
-		if err != nil {
-			return err
-		}
-		if data == nil {
-			data = map[string]any{}
-		}
-
-		items := common.GetSlice(data, "items")
-		hasMore, _ := data["has_more"].(bool)
-		pageToken, _ := data["page_token"].(string)
-
-		// Transform items to structured output
-		outItems := make([]searchEventItem, 0, len(items))
-		for _, raw := range items {
-			item, _ := raw.(map[string]any)
-			if item == nil {
-				continue
-			}
-			meta, _ := item["meta_data"].(map[string]any)
-			out := searchEventItem{}
-			if meta != nil {
-				if v, ok := meta["event_id"].(string); ok {
-					out.EventID = v
-				}
-				if v, ok := meta["summary"].(string); ok {
-					out.Summary = v
-				}
-				if v, ok := meta["is_all_day"].(bool); ok {
-					out.IsAllDay = v
-				}
-				if v, ok := meta["app_link"].(string); ok {
-					out.AppLink = v
-				}
-				if start, ok := meta["start"].(map[string]any); ok {
-					out.Start = extractTimeInfo(start)
-				}
-				if end, ok := meta["end"].(map[string]any); ok {
-					out.End = extractTimeInfo(end)
-				}
-			}
-			outItems = append(outItems, out)
-		}
-
-		outData := searchEventOutput{
-			CalendarID: calendarID,
-			Items:      outItems,
-			HasMore:    hasMore,
-			PageToken:  pageToken,
-		}
-
-		runtime.OutFormat(outData, &output.Meta{Count: len(outItems)}, func(w io.Writer) {
-			if len(outItems) == 0 {
-				fmt.Fprintln(w, "No events found.")
-				return
-			}
-			var rows []map[string]interface{}
-			for _, item := range outItems {
-				row := map[string]interface{}{
-					"event_id": item.EventID,
-					"summary":  common.TruncateStr(item.Summary, 40),
-				}
-				if item.Start != nil {
-					if item.Start.DateTime != "" {
-						row["start"] = item.Start.DateTime
-					} else if item.Start.Date != "" {
-						row["start"] = item.Start.Date
-					}
-				}
-				if item.End != nil {
-					if item.End.DateTime != "" {
-						row["end"] = item.End.DateTime
-					} else if item.End.Date != "" {
-						row["end"] = item.End.Date
-					}
-				}
-				if item.IsAllDay {
-					row["is_all_day"] = true
-				}
-				rows = append(rows, row)
-			}
-			output.PrintTable(w, rows)
-			fmt.Fprintf(w, "\n%d event(s) found\n", len(outItems))
-		})
-
-		if hasMore && runtime.Format != "json" && runtime.Format != "" {
-			fmt.Fprintf(runtime.IO().Out, "\n(more available, page_token: %s)\n", pageToken)
-		}
-		return nil
-	},
-}

shortcuts/calendar/calendar_test.go

@@ -2234,10 +2234,10 @@ func TestResolveStartEnd_ExplicitValues(t *testing.T) {
 // Shortcuts() registration test
 // ---------------------------------------------------------------------------
 
-func TestShortcuts_Returns9(t *testing.T) {
+func TestShortcuts_Returns7(t *testing.T) {
 	shortcuts := Shortcuts()
-	if len(shortcuts) != 9 {
-		t.Fatalf("expected 9 shortcuts, got %d", len(shortcuts))
+	if len(shortcuts) != 7 {
+		t.Fatalf("expected 7 shortcuts, got %d", len(shortcuts))
 	}
 
 	names := map[string]bool{}

shortcuts/calendar/errors.go

@@ -42,30 +42,3 @@ func withParam(err error, flag string) error {
 	}
 	return err
 }
-
-// unwrapCalendarAPIError returns a user-facing message extracted from a
-// calendar business-domain *errs.APIError, or "" when the error is not an
-// APIError or its Code is not specialized here. Callers should fall back to
-// err.Error() on "".
-//
-// Today it handles:
-//   - 190014 (invalid_parameters): returns Problem.Hint, which carries the
-//     server-supplied field-level detail (e.g. "end_time should be later
-//     than start_time") lifted by errclass.BuildAPIError.
-//
-// Add additional 19xxxx codes here as they become worth surfacing — keep this
-// the single switch site so call sites stay readable.
-func unwrapCalendarAPIError(err error) string {
-	if err == nil {
-		return ""
-	}
-	var ae *errs.APIError
-	if !errors.As(err, &ae) {
-		return ""
-	}
-	switch ae.Code {
-	case 190014:
-		return ae.Hint
-	}
-	return ""
-}

shortcuts/calendar/errors_attribution_test.go

@@ -240,62 +240,3 @@ func TestParseCalendarAttendeeIDs_Valid(t *testing.T) {
 		t.Errorf("dedup/trim failed: got %v", ids)
 	}
 }
-
-// ---------------------------------------------------------------------------
-// unwrapCalendarAPIError helper
-// ---------------------------------------------------------------------------
-
-func TestUnwrapCalendarAPIError_NilReturnsEmpty(t *testing.T) {
-	if got := unwrapCalendarAPIError(nil); got != "" {
-		t.Errorf("nil err should return empty string, got %q", got)
-	}
-}
-
-func TestUnwrapCalendarAPIError_NonAPIErrorReturnsEmpty(t *testing.T) {
-	// Validation, internal, and plain errors are not calendar API business
-	// errors; the helper must signal "no specialization" so callers fall back.
-	cases := []error{
-		errs.NewValidationError(errs.SubtypeInvalidArgument, "bad input"),
-		errs.NewInternalError(errs.SubtypeSDKError, "io failure"),
-		errors.New("plain error"),
-	}
-	for _, e := range cases {
-		if got := unwrapCalendarAPIError(e); got != "" {
-			t.Errorf("unwrapCalendarAPIError(%T) = %q, want empty", e, got)
-		}
-	}
-}
-
-func TestUnwrapCalendarAPIError_Code190014_ReturnsHint(t *testing.T) {
-	ae := errs.NewAPIError(errs.SubtypeInvalidParameters, "invalid params").
-		WithCode(190014).
-		WithHint("end_time should be later than start_time")
-	got := unwrapCalendarAPIError(ae)
-	if got != "end_time should be later than start_time" {
-		t.Errorf("expected lifted hint, got %q", got)
-	}
-}
-
-func TestUnwrapCalendarAPIError_Code190014_WrappedStillResolves(t *testing.T) {
-	// withStepContext wraps the typed error but errors.As must still find it.
-	inner := errs.NewAPIError(errs.SubtypeInvalidParameters, "invalid params").
-		WithCode(190014).
-		WithHint("calendar_id is required")
-	wrapped := withStepContext(inner, "while fetching meeting info for %s", "evt_x")
-	got := unwrapCalendarAPIError(wrapped)
-	if !strings.Contains(got, "calendar_id is required") {
-		t.Errorf("expected wrapped 190014 to surface hint, got %q", got)
-	}
-}
-
-func TestUnwrapCalendarAPIError_UnhandledCodeReturnsEmpty(t *testing.T) {
-	// An APIError carrying a code that isn't specialized here should return
-	// "" so callers fall back to err.Error() — keeps the helper conservative
-	// while we add 19xxxx codes incrementally.
-	ae := errs.NewAPIError(errs.SubtypeInvalidParameters, "some other error").
-		WithCode(190099).
-		WithHint("ignore me")
-	if got := unwrapCalendarAPIError(ae); got != "" {
-		t.Errorf("unhandled code should return empty, got %q", got)
-	}
-}

shortcuts/calendar/shortcuts.go

@@ -15,7 +15,5 @@ func Shortcuts() []common.Shortcut {
 		CalendarRoomFind,
 		CalendarRsvp,
 		CalendarSuggestion,
-		CalendarMeeting,
-		CalendarSearchEvent,
 	}
 }

shortcuts/common/artifact_path.go

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 
 // This file defines artifact-path conventions shared between
-// `minutes +download` and `minutes +detail`. Callers outside those two shortcuts
+// `minutes +download` and `vc +notes`. Callers outside those two shortcuts
 // should not take a dependency on these symbols.
 
 package common

shortcuts/doc/doc_errors_test.go

@@ -203,13 +203,6 @@ func TestValidateCreateV2Contract(t *testing.T) {
 	}
 }
 
-func TestValidateCreateV2AllowsTitleWithoutContent(t *testing.T) {
-	rt := docValidateRuntime(t, map[string]string{"title": "Only Title"}, nil, nil)
-	if err := validateCreateV2(context.Background(), rt); err != nil {
-		t.Fatalf("validateCreateV2() error = %v, want nil", err)
-	}
-}
-
 func TestValidateFetchV2Contract(t *testing.T) {
 	cases := []struct {
 		name       string

shortcuts/doc/docs_create_test.go

@@ -90,6 +90,7 @@ func TestDocsCreateV2BotAutoGrantSkippedWithoutCurrentUser(t *testing.T) {
 
 	err := runDocsCreateShortcut(t, f, stdout, []string{
 		"+create",
+		"--api-version", "v2",
 		"--content", "<title>内容</title><p>正文</p>",
 		"--as", "bot",
 	})
@@ -124,6 +125,7 @@ func TestDocsCreateV2UserSkipsPermissionGrantAugmentation(t *testing.T) {
 
 	err := runDocsCreateShortcut(t, f, stdout, []string{
 		"+create",
+		"--api-version", "v2",
 		"--content", "<title>内容</title><p>正文</p>",
 		"--as", "user",
 	})
@@ -161,6 +163,7 @@ func TestDocsCreateV2BotAutoGrantFailureDoesNotFailCreate(t *testing.T) {
 
 	err := runDocsCreateShortcut(t, f, stdout, []string{
 		"+create",
+		"--api-version", "v2",
 		"--content", "<title>内容</title><p>正文</p>",
 		"--as", "bot",
 	})
@@ -198,6 +201,7 @@ func TestDocsCreateV2FallbackURLWhenBackendOmitsIt(t *testing.T) {
 
 	err := runDocsCreateShortcut(t, f, stdout, []string{
 		"+create",
+		"--api-version", "v2",
 		"--content", "<title>内容</title><p>正文</p>",
 		"--as", "user",
 	})
@@ -229,6 +233,7 @@ func TestDocsCreateV2PreservesBackendURL(t *testing.T) {
 
 	err := runDocsCreateShortcut(t, f, stdout, []string{
 		"+create",
+		"--api-version", "v2",
 		"--content", "<title>内容</title><p>正文</p>",
 		"--as", "user",
 	})
@@ -243,7 +248,7 @@ func TestDocsCreateV2PreservesBackendURL(t *testing.T) {
 	}
 }
 
-func TestDocsCreateAPIVersionCompatFlagIsIgnored(t *testing.T) {
+func TestDocsCreateAPIVersionV1StillUsesV2Endpoint(t *testing.T) {
 	t.Parallel()
 
 	f, stdout, _, reg := cmdutil.TestFactory(t, docsCreateTestConfig(t, ""))
@@ -257,7 +262,7 @@ func TestDocsCreateAPIVersionCompatFlagIsIgnored(t *testing.T) {
 
 	err := runDocsCreateShortcut(t, f, stdout, []string{
 		"+create",
-		"--api-version", "legacy",
+		"--api-version", "v1",
 		"--content", "<title>项目计划</title>",
 		"--as", "user",
 	})
@@ -277,6 +282,7 @@ func TestDocsCreateRejectsLegacyV1Flags(t *testing.T) {
 	f, stdout, _, _ := cmdutil.TestFactory(t, docsCreateTestConfig(t, ""))
 	err := runDocsCreateShortcut(t, f, stdout, []string{
 		"+create",
+		"--title", "项目计划",
 		"--markdown", "## 目标",
 		"--as", "user",
 	})
@@ -286,7 +292,8 @@ func TestDocsCreateRejectsLegacyV1Flags(t *testing.T) {
 	for _, want := range []string{
 		"docs +create is v2-only",
 		"the old v1 interface has been shut down",
-		"legacy v1 flag(s) --markdown are no longer supported",
+		"legacy v1 flag(s) --title, --markdown are no longer supported",
+		"--title -> put the title in --content",
 		"--markdown -> use --content with --doc-format markdown",
 		"lark-cli skills read lark-doc references/lark-doc-create.md",
 		"lark-cli skills read lark-doc references/lark-doc-xml.md",

shortcuts/doc/docs_create_v2.go

@@ -4,9 +4,7 @@
 package doc
 
 import (
-	"bytes"
 	"context"
-	"encoding/xml"
 	"strings"
 
 	"github.com/larksuite/cli/errs"
@@ -16,7 +14,6 @@ import (
 // v2CreateFlags returns the flag definitions for the v2 (OpenAPI) create path.
 func v2CreateFlags() []common.Flag {
 	return []common.Flag{
-		{Name: "title", Desc: "document title; when provided, the CLI prepends it to --content as <title>...</title> so the title wins over later content titles"},
 		{Name: "content", Desc: "document body; XML by default or Markdown when --doc-format markdown. " + docsContentSkillHelp + "; use --help for the latest command flags", Input: []string{common.File, common.Stdin}},
 		{Name: "doc-format", Desc: "content format; xml is default and supports richer DocxXML blocks, markdown imports plain Markdown", Default: "xml", Enum: []string{"xml", "markdown"}},
 		{Name: "parent-token", Desc: "parent folder token or wiki node token; mutually exclusive with --parent-position"},
@@ -28,12 +25,8 @@ func validateCreateV2(_ context.Context, runtime *common.RuntimeContext) error {
 	if err := validateDocsV2Only(runtime, "+create", docsCreateLegacyFlags()); err != nil {
 		return err
 	}
-	title := strings.TrimSpace(runtime.Str("title"))
-	if runtime.Changed("title") && title == "" {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--title must not be empty").WithParam("--title")
-	}
-	if runtime.Str("content") == "" && title == "" {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--content is required unless --title is provided").WithParam("--content")
+	if runtime.Str("content") == "" {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--content is required").WithParam("--content")
 	}
 	if runtime.Str("parent-token") != "" && runtime.Str("parent-position") != "" {
 		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--parent-token and --parent-position are mutually exclusive").WithParams(
@@ -73,7 +66,7 @@ func executeCreateV2(_ context.Context, runtime *common.RuntimeContext) error {
 func buildCreateBody(runtime *common.RuntimeContext) map[string]interface{} {
 	body := map[string]interface{}{
 		"format":  runtime.Str("doc-format"),
-		"content": buildCreateContent(runtime),
+		"content": runtime.Str("content"),
 	}
 	if v := runtime.Str("parent-token"); v != "" {
 		body["parent_token"] = v
@@ -85,26 +78,6 @@ func buildCreateBody(runtime *common.RuntimeContext) map[string]interface{} {
 	return body
 }
 
-func buildCreateContent(runtime *common.RuntimeContext) string {
-	content := runtime.Str("content")
-	title := strings.TrimSpace(runtime.Str("title"))
-	if title == "" {
-		return content
-	}
-
-	titleTag := "<title>" + escapeDocTitleText(title) + "</title>"
-	if content == "" {
-		return titleTag
-	}
-	return titleTag + "\n" + content
-}
-
-func escapeDocTitleText(title string) string {
-	var buf bytes.Buffer
-	_ = xml.EscapeText(&buf, []byte(title))
-	return buf.String()
-}
-
 // augmentDocsCreatePermission grants full_access to the current CLI user when
 // the document was created with bot identity.
 func augmentDocsCreatePermission(runtime *common.RuntimeContext, data map[string]interface{}) {

shortcuts/doc/docs_fetch_v2_test.go

@@ -43,23 +43,6 @@ func TestBuildCreateBodyIncludesSceneFromContext(t *testing.T) {
 	}
 }
 
-func TestBuildCreateBodyPrependsTitleToContent(t *testing.T) {
-	t.Parallel()
-
-	runtime := newCreateBodyTestRuntime(context.Background())
-	if err := runtime.Cmd.Flags().Set("title", "A & B <C>"); err != nil {
-		t.Fatalf("set title: %v", err)
-	}
-	if err := runtime.Cmd.Flags().Set("content", "## Body"); err != nil {
-		t.Fatalf("set content: %v", err)
-	}
-
-	body := buildCreateBody(runtime)
-	if got, want := body["content"], "<title>A &amp; B &lt;C&gt;</title>\n## Body"; got != want {
-		t.Fatalf("content = %#v, want %q", got, want)
-	}
-}
-
 func TestBuildUpdateBodyIncludesSceneFromContext(t *testing.T) {
 	t.Parallel()
 
@@ -507,10 +490,10 @@ func TestDocsFetchDryRunDefaultsToV2Endpoint(t *testing.T) {
 	}
 }
 
-func TestDocsFetchAPIVersionCompatFlagIsIgnored(t *testing.T) {
+func TestDocsFetchAPIVersionV1StillUsesV2Endpoint(t *testing.T) {
 	t.Parallel()
 
-	runtime := newFetchShortcutTestRuntime(t, "legacy", nil)
+	runtime := newFetchShortcutTestRuntime(t, "v1", nil)
 	if err := validateFetchV2(context.Background(), runtime); err != nil {
 		t.Fatalf("validateFetchV2() error = %v", err)
 	}
@@ -862,7 +845,6 @@ func newFetchShortcutTestRuntime(t *testing.T, apiVersion string, setFlags map[s
 func newCreateBodyTestRuntime(ctx context.Context) *common.RuntimeContext {
 	cmd := &cobra.Command{Use: "+create"}
 	cmd.Flags().String("doc-format", "xml", "")
-	cmd.Flags().String("title", "", "")
 	cmd.Flags().String("content", "<title>hello</title>", "")
 	cmd.Flags().String("parent-token", "", "")
 	cmd.Flags().String("parent-position", "", "")

shortcuts/doc/docs_update_test.go

@@ -34,8 +34,8 @@ func TestValidCommandsV2(t *testing.T) {
 	}
 }
 
-func TestDocsUpdateDryRunIgnoresAPIVersionCompatFlag(t *testing.T) {
-	for _, apiVersion := range []string{"v1", "v2", "legacy"} {
+func TestDocsUpdateDryRunAcceptsDeprecatedAPIVersionValues(t *testing.T) {
+	for _, apiVersion := range []string{"v1", "v2"} {
 		t.Run(apiVersion, func(t *testing.T) {
 			t.Parallel()
 

shortcuts/doc/v2_only.go

@@ -17,14 +17,15 @@ type docsLegacyFlag struct {
 
 func docsAPIVersionCompatFlag() common.Flag {
 	return common.Flag{
-		Name:   "api-version",
-		Desc:   "deprecated compatibility flag; ignored by docs shortcuts",
-		Hidden: true,
+		Name:    "api-version",
+		Desc:    "deprecated compatibility flag; docs shortcuts always use v2, and both v1/v2 are accepted for rollback-safe skill examples",
+		Default: "v2",
 	}
 }
 
 func docsCreateLegacyFlags() []docsLegacyFlag {
 	return []docsLegacyFlag{
+		{Name: "title", Replacement: "put the title in --content, for example <title>Title</title>"},
 		{Name: "markdown", Replacement: "use --content with --doc-format markdown"},
 		{Name: "folder-token", Replacement: "use --parent-token"},
 		{Name: "wiki-node", Replacement: "use --parent-token"},
@@ -54,7 +55,7 @@ func docsLegacyFlagDefinitions(flags []docsLegacyFlag) []common.Flag {
 	for _, flag := range flags {
 		out = append(out, common.Flag{
 			Name:   flag.Name,
-			Desc:   "deprecated compatibility flag; run `lark-cli skills read lark-doc` for the current CLI skill",
+			Desc:   "deprecated v1 compatibility flag; run `lark-cli skills read lark-doc` for the v2 CLI skill",
 			Hidden: true,
 		})
 	}
@@ -62,6 +63,12 @@ func docsLegacyFlagDefinitions(flags []docsLegacyFlag) []common.Flag {
 }
 
 func validateDocsV2Only(runtime *common.RuntimeContext, shortcut string, legacyFlags []docsLegacyFlag) error {
+	switch apiVersion := strings.TrimSpace(runtime.Str("api-version")); apiVersion {
+	case "", "v1", "v2":
+	default:
+		return docsV2OnlyError(shortcut, "--api-version is deprecated and only accepts v1 or v2; both values execute the v2 API", "--api-version")
+	}
+
 	var used []string
 	var replacements []string
 	for _, flag := range legacyFlags {

shortcuts/doc/v2_only_test.go

@@ -11,8 +11,8 @@ import (
 	"github.com/spf13/cobra"
 )
 
-func TestValidateDocsV2OnlyIgnoresAPIVersionValues(t *testing.T) {
-	for _, apiVersion := range []string{"", "v1", "v2", "v0", "legacy"} {
+func TestValidateDocsV2OnlyAllowsDefaultAndDeprecatedAPIVersionValues(t *testing.T) {
+	for _, apiVersion := range []string{"", "v1", "v2"} {
 		t.Run(apiVersion, func(t *testing.T) {
 			runtime := docsV2OnlyTestRuntime(t, apiVersion, false)
 			if err := validateDocsV2Only(runtime, "+update", []docsLegacyFlag{{Name: "mode", Replacement: "use --command"}}); err != nil {
@@ -22,6 +22,28 @@ func TestValidateDocsV2OnlyIgnoresAPIVersionValues(t *testing.T) {
 	}
 }
 
+func TestValidateDocsV2OnlyRejectsUnknownAPIVersion(t *testing.T) {
+	runtime := docsV2OnlyTestRuntime(t, "v0", false)
+	err := validateDocsV2Only(runtime, "+fetch", nil)
+	if err == nil {
+		t.Fatal("expected unknown --api-version to be rejected")
+	}
+	for _, want := range []string{
+		"docs +fetch is v2-only",
+		"--api-version is deprecated and only accepts v1 or v2",
+		"both values execute the v2 API",
+		"lark-cli skills read lark-doc references/lark-doc-fetch.md",
+		"lark-cli skills read lark-doc references/lark-doc-xml.md",
+		"lark-cli skills read lark-doc references/lark-doc-md.md",
+		"MUST NOT grep/open local SKILL.md files",
+		"lark-cli docs +fetch --help",
+	} {
+		if !strings.Contains(err.Error(), want) {
+			t.Fatalf("error missing %q: %v", want, err)
+		}
+	}
+}
+
 func TestValidateDocsV2OnlyRejectsChangedLegacyFlags(t *testing.T) {
 	runtime := docsV2OnlyTestRuntime(t, "", true)
 	err := validateDocsV2Only(runtime, "+update", []docsLegacyFlag{{Name: "mode", Replacement: "use --command"}})

shortcuts/drive/drive_member_add.go

@@ -1,686 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package drive
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/url"
-	"strconv"
-	"strings"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// driveMemberAddIDTypes covers every user-facing --member-type value accepted
-// by the shortcut. Some values are normalized before hitting the API.
-var driveMemberAddIDTypes = []string{
-	"email", "openid", "unionid", "openchat", "opendepartmentid",
-	"groupid", "appid", "wikispaceid",
-}
-
-var driveMemberAddPerms = []string{"view", "edit", "full_access"}
-var driveMemberAddPermTypes = []string{"container", "single_page"}
-var driveMemberAddWikiSpaceMemberKinds = []string{"wiki_space_member", "wiki_space_viewer", "wiki_space_editor"}
-
-// driveMemberAddPrefixToType maps ID prefixes to their expected member_type
-// for conflict validation when --member-type is provided explicitly.
-var driveMemberAddPrefixToType = map[string]string{
-	"ou_": "openid",
-	"on_": "unionid",
-	"oc_": "openchat",
-	"od_": "opendepartmentid",
-}
-
-var driveMemberAddURLPathToType = []struct {
-	Prefix string
-	Type   string
-}{
-	{"/drive/folder/", "folder"},
-	{"/docx/", "docx"},
-	{"/doc/", "doc"},
-	{"/sheets/", "sheet"},
-	{"/base/", "bitable"},
-	{"/bitable/", "bitable"},
-	{"/wiki/", "wiki"},
-	{"/file/", "file"},
-	{"/mindnotes/", "mindnote"},
-	{"/slides/", "slides"},
-	{"/minutes/", "minutes"},
-}
-
-var driveMemberAddResourceTypes = []string{"docx", "doc", "sheet", "bitable", "file", "folder", "wiki", "mindnote", "slides", "minutes"}
-
-const driveMemberAddBatchLimit = 10
-
-// DriveMemberAdd adds a collaborator/member permission to a Drive resource.
-var DriveMemberAdd = common.Shortcut{
-	Service:     "drive",
-	Command:     "+member-add",
-	Description: "Add a collaborator/member permission to a Drive document, file, folder, or wiki node",
-	Risk:        "high-risk-write",
-	Scopes:      []string{"docs:permission.member:create"},
-	AuthTypes:   []string{"user", "bot"},
-	HasFormat:   true,
-	Flags: []common.Flag{
-		{Name: "token", Desc: "target token or document URL; type is auto-inferred from URL path when omitted", Required: true},
-		{Name: "type", Desc: "target resource type; required when --token is a bare token"},
-		{Name: "member-id", Desc: "collaborator ID; comma-separated for batch (max 10). Interpretation is decided by --member-type", Required: true},
-		{Name: "member-type", Desc: "ID type for --member-id; supported: email|openid|unionid|openchat|opendepartmentid|groupid|appid|wikispaceid", Required: true},
-		{Name: "member-kind", Desc: "request body type when --member-type=wikispaceid; one of wiki_space_member|wiki_space_viewer|wiki_space_editor"},
-		{Name: "perm", Desc: "permission role to grant; defaults to view"},
-		{Name: "perm-type", Desc: "wiki permission scope; defaults to container; rejected for non-wiki types"},
-		{Name: "need-notification", Type: "bool", Desc: "send an in-app notification after the grant (user identity only)"},
-	},
-	Tips: []string{
-		"Resource type is auto-inferred from URL paths; pass --type when --token is a bare token.",
-		"Supported --member-type values: email, openid, unionid, openchat, opendepartmentid, groupid, appid, wikispaceid.",
-		"When --member-type=wikispaceid, pass --member-kind wiki_space_member, wiki_space_viewer, or wiki_space_editor.",
-		"--member-type is required; if the ID prefix conflicts with --member-type (e.g. ou_xxx with email), the command rejects it.",
-		"--perm defaults to view (safest); use --dry-run first when granting edit or full_access.",
-		"For wiki nodes, --perm-type defaults to container (current page and sub-pages), except --member-type=wikispaceid where --member-kind provides the wiki-space role.",
-		"Department collaborator (--member-type=opendepartmentid) requires --as user; bot identity is not supported for department authorization.",
-	},
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		_, err := readDriveMemberAddSpec(runtime)
-		return err
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		spec, err := readDriveMemberAddSpec(runtime)
-		if err != nil {
-			return common.NewDryRunAPI().Set("error", err.Error())
-		}
-		return buildDriveMemberAddDryRun(spec)
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		spec, err := readDriveMemberAddSpec(runtime)
-		if err != nil {
-			return err
-		}
-
-		if len(spec.MemberIDs) == 1 {
-			return executeDriveMemberAddSingle(runtime, spec)
-		}
-		return executeDriveMemberAddBatch(runtime, spec)
-	},
-}
-
-// driveMemberAddSpec is the normalized request model shared by Validate,
-// DryRun, Execute, and output shaping so they all observe the same defaults.
-type driveMemberAddSpec struct {
-	Token        string
-	ResourceType string
-	MemberIDs    []string
-	MemberType   string
-	// MemberKind is the explicit --member-kind value for member_type=wikispaceid.
-	MemberKind       string
-	Perm             string
-	PermType         string
-	NeedNotification bool
-	NotificationSet  bool
-}
-
-// DryRunParams builds the preview query string while preserving the semantic
-// difference between an omitted notification flag and an explicit false.
-func (spec driveMemberAddSpec) DryRunParams() map[string]interface{} {
-	params := map[string]interface{}{"type": spec.ResourceType}
-	if spec.NotificationSet {
-		params["need_notification"] = spec.NeedNotification
-	}
-	return params
-}
-
-// APIQueryParams builds the query params for permission.members.create.
-func (spec driveMemberAddSpec) APIQueryParams() map[string]interface{} {
-	params := map[string]interface{}{"type": spec.ResourceType}
-	if spec.NotificationSet {
-		params["need_notification"] = strconv.FormatBool(spec.NeedNotification)
-	}
-	return params
-}
-
-// buildMemberBody builds a single member object for the request body.
-func buildMemberBody(memberID, memberType, wikiSpaceMemberKind, perm, permType string) map[string]interface{} {
-	body := map[string]interface{}{
-		"member_id":   memberID,
-		"member_type": memberType,
-		"perm":        perm,
-	}
-	if bodyType := driveMemberAddBodyType(memberType, wikiSpaceMemberKind); bodyType != "" {
-		body["type"] = bodyType
-	}
-	if permType != "" {
-		body["perm_type"] = permType
-	}
-	return body
-}
-
-// readDriveMemberAddSpec parses runtime flags into a normalized request model,
-// applying inference, defaults, and cross-field validation in one place.
-func readDriveMemberAddSpec(runtime *common.RuntimeContext) (driveMemberAddSpec, error) {
-	token, resourceType, err := resolveDriveMemberAddTarget(runtime.Str("token"), runtime.Str("type"))
-	if err != nil {
-		return driveMemberAddSpec{}, err
-	}
-
-	// Parse member-id: comma-separated for batch.
-	rawMemberID := strings.TrimSpace(runtime.Str("member-id"))
-	if rawMemberID == "" {
-		return driveMemberAddSpec{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "--member-id is required and cannot be blank").WithParam("--member-id")
-	}
-	memberIDs := splitAndTrimMembers(rawMemberID)
-	if len(memberIDs) == 0 {
-		return driveMemberAddSpec{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "--member-id is required and must contain at least one non-blank ID").WithParam("--member-id")
-	}
-	if len(memberIDs) > driveMemberAddBatchLimit {
-		return driveMemberAddSpec{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "--member-id accepts at most %d IDs, got %d", driveMemberAddBatchLimit, len(memberIDs)).WithParam("--member-id")
-	}
-	if duplicate, first, second, ok := firstDuplicateDriveMemberID(memberIDs); ok {
-		return driveMemberAddSpec{}, errs.NewValidationError(errs.SubtypeInvalidArgument,
-			"--member-id contains duplicate collaborator ID %q at positions %d and %d; remove duplicates before retrying",
-			duplicate, first+1, second+1,
-		).WithParam("--member-id")
-	}
-
-	memberType, err := resolveDriveMemberAddMemberType(memberIDs, runtime.Str("member-type"))
-	if err != nil {
-		return driveMemberAddSpec{}, err
-	}
-	memberKind, err := resolveDriveMemberAddMemberKind(memberType, runtime.Str("member-kind"))
-	if err != nil {
-		return driveMemberAddSpec{}, err
-	}
-
-	// perm: default to view.
-	perm, err := normalizeDriveMemberAddEnumValue(runtime.Str("perm"), driveMemberAddPerms, "--perm")
-	if err != nil {
-		return driveMemberAddSpec{}, err
-	}
-	if perm == "" {
-		perm = "view"
-	}
-
-	// perm-type: only meaningful for wiki; default container except for wiki-space collaborators.
-	permType, err := normalizeDriveMemberAddEnumValue(runtime.Str("perm-type"), driveMemberAddPermTypes, "--perm-type")
-	if err != nil {
-		return driveMemberAddSpec{}, err
-	}
-	if resourceType == "wiki" && memberType == "wikispaceid" {
-		if runtime.Changed("perm-type") {
-			return driveMemberAddSpec{}, errs.NewValidationError(
-				errs.SubtypeInvalidArgument,
-				"--perm-type is not supported when --member-type=wikispaceid; use --member-kind wiki_space_member|wiki_space_viewer|wiki_space_editor to set the wiki-space role",
-			).WithParam("--perm-type")
-		}
-		permType = ""
-	} else if resourceType == "wiki" && permType == "" {
-		permType = driveMemberAddDefaultPermType(resourceType)
-	} else if resourceType != "wiki" && runtime.Changed("perm-type") {
-		return driveMemberAddSpec{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "--perm-type only applies when resource type is wiki; got %q", resourceType).WithParam("--perm-type")
-	} else if resourceType != "wiki" {
-		permType = ""
-	}
-
-	spec := driveMemberAddSpec{
-		Token:            token,
-		ResourceType:     resourceType,
-		MemberIDs:        memberIDs,
-		MemberType:       memberType,
-		MemberKind:       memberKind,
-		Perm:             perm,
-		PermType:         permType,
-		NeedNotification: runtime.Bool("need-notification"),
-		NotificationSet:  runtime.Changed("need-notification"),
-	}
-	if runtime.As().IsBot() && spec.NotificationSet {
-		return driveMemberAddSpec{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "--need-notification is only valid with --as user; omit it when using --as bot").WithParam("--need-notification")
-	}
-	if runtime.As().IsBot() && spec.MemberType == "opendepartmentid" {
-		return driveMemberAddSpec{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "--member-type=opendepartmentid requires --as user; bot identity does not support adding department collaborators").WithParam("--member-type")
-	}
-	return spec, nil
-}
-
-// resolveDriveMemberAddTarget extracts (token, type) from a user-supplied
-// --token value that may be either a bare token or a full resource URL, plus an
-// optional explicit --type. Explicit --type wins over URL inference.
-func resolveDriveMemberAddTarget(raw, explicitType string) (token, resourceType string, err error) {
-	raw = strings.TrimSpace(raw)
-	if raw == "" {
-		return "", "", errs.NewValidationError(errs.SubtypeInvalidArgument, "--token is required").WithParam("--token")
-	}
-	explicitType = strings.ToLower(strings.TrimSpace(explicitType))
-
-	if strings.Contains(raw, "://") {
-		parsed, parseErr := url.Parse(raw)
-		if parseErr != nil || parsed.Hostname() == "" {
-			return "", "", errs.NewValidationError(errs.SubtypeInvalidArgument, "--token URL is malformed: %q", raw).WithParam("--token")
-		}
-		urlToken, urlType, ok := parseDriveMemberAddResourceURLPath(parsed.Path)
-		if !ok {
-			return "", "", errs.NewValidationError(errs.SubtypeInvalidArgument,
-				"unsupported URL path %q: expected one of %s followed by a token",
-				parsed.Path, strings.Join(driveMemberAddSupportedURLPaths(), ", "),
-			).WithParam("--token")
-		}
-		token = urlToken
-		if explicitType == "" {
-			resourceType = urlType
-		}
-	} else {
-		token = raw
-	}
-
-	if explicitType != "" {
-		if !isSupportedDriveMemberAddResourceType(explicitType) {
-			return "", "", errs.NewValidationError(errs.SubtypeInvalidArgument, "--type must be one of: %s", strings.Join(driveMemberAddResourceTypes, ", ")).WithParam("--type")
-		}
-		resourceType = explicitType
-	}
-
-	if resourceType == "" {
-		return "", "", errs.NewValidationError(errs.SubtypeInvalidArgument,
-			"--type is required when --token is a bare token; accepted values: %s",
-			strings.Join(driveMemberAddResourceTypes, ", "),
-		).WithParam("--type")
-	}
-	return token, resourceType, nil
-}
-
-func driveMemberAddSupportedURLPaths() []string {
-	paths := make([]string, 0, len(driveMemberAddURLPathToType))
-	for _, mapping := range driveMemberAddURLPathToType {
-		paths = append(paths, mapping.Prefix)
-	}
-	return paths
-}
-
-func parseDriveMemberAddResourceURLPath(path string) (token, resourceType string, ok bool) {
-	for _, mapping := range driveMemberAddURLPathToType {
-		if !strings.HasPrefix(path, mapping.Prefix) {
-			continue
-		}
-		token := path[len(mapping.Prefix):]
-		token = strings.TrimRight(token, "/")
-		if idx := strings.IndexByte(token, '/'); idx >= 0 {
-			token = token[:idx]
-		}
-		token = strings.TrimSpace(token)
-		if token == "" {
-			return "", "", false
-		}
-		return token, mapping.Type, true
-	}
-	return "", "", false
-}
-
-func isSupportedDriveMemberAddResourceType(resourceType string) bool {
-	switch resourceType {
-	case "docx", "doc", "sheet", "bitable", "file", "folder", "wiki", "mindnote", "slides", "minutes":
-		return true
-	default:
-		return false
-	}
-}
-
-func resolveDriveMemberAddMemberType(memberIDs []string, explicit string) (string, error) {
-	var err error
-	explicit, err = normalizeDriveMemberAddEnumValue(explicit, driveMemberAddIDTypes, "--member-type")
-	if err != nil {
-		return "", err
-	}
-	if explicit == "" {
-		return "", errs.NewValidationError(errs.SubtypeInvalidArgument, "--member-type is required; accepted values: %s", strings.Join(driveMemberAddIDTypes, ", ")).WithParam("--member-type")
-	}
-	for i, memberID := range memberIDs {
-		if expected := inferMemberTypeFromID(memberID); expected != "" && expected != explicit {
-			return "", errs.NewValidationError(errs.SubtypeInvalidArgument,
-				"member-id[%d] %q prefix implies --member-type %s, but --member-type %s was provided; fix the ID or use the matching member type",
-				i+1, memberID, expected, explicit,
-			).WithParam("--member-id")
-		}
-	}
-	return normalizeDriveMemberAddMemberType(explicit), nil
-}
-
-func resolveDriveMemberAddMemberKind(memberType, raw string) (string, error) {
-	memberKind, err := normalizeDriveMemberAddEnumValue(raw, driveMemberAddWikiSpaceMemberKinds, "--member-kind")
-	if err != nil {
-		return "", err
-	}
-	if memberType == "wikispaceid" {
-		if memberKind == "" {
-			return "", errs.NewValidationError(
-				errs.SubtypeInvalidArgument,
-				"--member-kind is required when --member-type=wikispaceid; allowed: %s",
-				strings.Join(driveMemberAddWikiSpaceMemberKinds, ", "),
-			).WithParam("--member-kind")
-		}
-		return memberKind, nil
-	}
-	if memberKind != "" {
-		return "", errs.NewValidationError(errs.SubtypeInvalidArgument, "--member-kind only applies when --member-type=wikispaceid").WithParam("--member-kind")
-	}
-	return "", nil
-}
-
-func normalizeDriveMemberAddMemberType(memberType string) string {
-	return strings.ToLower(strings.TrimSpace(memberType))
-}
-
-func normalizeDriveMemberAddEnumValue(raw string, allowed []string, flagName string) (string, error) {
-	value := strings.TrimSpace(raw)
-	if value == "" {
-		return "", nil
-	}
-	for _, candidate := range allowed {
-		if strings.EqualFold(value, candidate) {
-			return candidate, nil
-		}
-	}
-	return "", errs.NewValidationError(
-		errs.SubtypeInvalidArgument,
-		"invalid value %q for %s, allowed: %s",
-		value,
-		flagName,
-		strings.Join(allowed, ", "),
-	).WithParam(flagName)
-}
-
-// splitAndTrimMembers splits a comma-separated member-id string and trims whitespace.
-func splitAndTrimMembers(raw string) []string {
-	parts := strings.Split(raw, ",")
-	var result []string
-	for _, p := range parts {
-		p = strings.TrimSpace(p)
-		if p != "" {
-			result = append(result, p)
-		}
-	}
-	return result
-}
-
-func firstDuplicateDriveMemberID(memberIDs []string) (duplicate string, first, second int, ok bool) {
-	seen := make(map[string]int, len(memberIDs))
-	for i, memberID := range memberIDs {
-		if prev, exists := seen[memberID]; exists {
-			return memberID, prev, i, true
-		}
-		seen[memberID] = i
-	}
-	return "", 0, 0, false
-}
-
-// inferMemberTypeFromID returns the expected member_type for a member-id
-// based on its prefix, or "" if no prefix matches (e.g. groupid).
-func inferMemberTypeFromID(memberID string) string {
-	memberID = strings.TrimSpace(memberID)
-	if memberID == "" {
-		return ""
-	}
-	if strings.Contains(memberID, "@") {
-		return "email"
-	}
-	for prefix, mtype := range driveMemberAddPrefixToType {
-		if strings.HasPrefix(memberID, prefix) {
-			return mtype
-		}
-	}
-	return ""
-}
-
-// driveMemberAddDefaultPermType returns the default perm_type for a given
-// resource type. For wiki nodes, container is the default for regular
-// collaborators. Wiki-space collaborators omit perm_type because their role is
-// carried by the body type field.
-func driveMemberAddDefaultPermType(resourceType string) string {
-	switch resourceType {
-	case "wiki":
-		return "container"
-	default:
-		return ""
-	}
-}
-
-// inferDriveMemberKind derives the request-body collaborator kind from
-// member-type for all supported member-type values.
-func inferDriveMemberKind(memberType string) string {
-	switch memberType {
-	case "email", "openid", "unionid", "userid":
-		return "user"
-	case "openchat":
-		return "chat"
-	case "opendepartmentid":
-		return "department"
-	case "groupid":
-		return "group"
-	default:
-		return ""
-	}
-}
-
-func driveMemberAddBodyType(memberType, wikiSpaceMemberKind string) string {
-	if memberType == "wikispaceid" {
-		return wikiSpaceMemberKind
-	}
-	return inferDriveMemberKind(memberType)
-}
-
-// buildDriveMemberAddDryRun renders the exact request preview for --dry-run.
-func buildDriveMemberAddDryRun(spec driveMemberAddSpec) *common.DryRunAPI {
-	if len(spec.MemberIDs) == 1 {
-		body := buildMemberBody(spec.MemberIDs[0], spec.MemberType, spec.MemberKind, spec.Perm, spec.PermType)
-		return common.NewDryRunAPI().
-			Desc("Add Drive collaborator/member permission").
-			POST(fmt.Sprintf("/open-apis/drive/v1/permissions/%s/members", validate.EncodePathSegment(spec.Token))).
-			Params(spec.DryRunParams()).
-			Body(body)
-	}
-
-	members := buildDriveMemberAddMemberBodies(spec)
-	return common.NewDryRunAPI().
-		Desc("Batch add Drive collaborator/member permissions").
-		POST(fmt.Sprintf("/open-apis/drive/v1/permissions/%s/members/batch_create", validate.EncodePathSegment(spec.Token))).
-		Params(spec.DryRunParams()).
-		Body(map[string]interface{}{"members": members})
-}
-
-// executeDriveMemberAddSingle calls the single-member create API.
-func executeDriveMemberAddSingle(runtime *common.RuntimeContext, spec driveMemberAddSpec) error {
-	fmt.Fprintf(runtime.IO().ErrOut, "Adding Drive member %s (type=%s, perm=%s) to %s %s...\n",
-		common.MaskToken(spec.MemberIDs[0]), spec.MemberType, spec.Perm, spec.ResourceType, common.MaskToken(spec.Token))
-
-	body := buildMemberBody(spec.MemberIDs[0], spec.MemberType, spec.MemberKind, spec.Perm, spec.PermType)
-	data, err := runtime.CallAPITyped(
-		"POST",
-		fmt.Sprintf("/open-apis/drive/v1/permissions/%s/members", validate.EncodePathSegment(spec.Token)),
-		spec.APIQueryParams(),
-		body,
-	)
-	if err != nil {
-		return err
-	}
-
-	out := driveMemberAddOutput(spec, spec.MemberIDs[0], common.GetMap(data, "member"))
-	fmt.Fprintf(runtime.IO().ErrOut, "Added Drive member %s\n", common.MaskToken(common.GetString(out, "member_id")))
-	runtime.Out(out, nil)
-	return nil
-}
-
-// executeDriveMemberAddBatch calls the batch_create API. A successful HTTP/API
-// response is treated as complete only when the server returns every requested
-// member_id, regardless of response array order.
-func executeDriveMemberAddBatch(runtime *common.RuntimeContext, spec driveMemberAddSpec) error {
-	members := buildDriveMemberAddMemberBodies(spec)
-
-	fmt.Fprintf(runtime.IO().ErrOut, "Adding %d Drive members (type=%s, perm=%s) to %s %s...\n",
-		len(spec.MemberIDs), spec.MemberType, spec.Perm, spec.ResourceType, common.MaskToken(spec.Token))
-
-	data, err := runtime.CallAPITyped(
-		"POST",
-		fmt.Sprintf("/open-apis/drive/v1/permissions/%s/members/batch_create", validate.EncodePathSegment(spec.Token)),
-		spec.APIQueryParams(),
-		map[string]interface{}{"members": members},
-	)
-	if err != nil {
-		return wrapDriveMemberAddBatchAPIError(err)
-	}
-
-	result := buildDriveMemberAddBatchResult(spec, data)
-	if common.GetBool(result, "partial") {
-		return runtime.OutPartialFailure(result, nil)
-	}
-
-	fmt.Fprintf(runtime.IO().ErrOut, "Added %d Drive member(s)\n", result["succeeded_count"])
-	runtime.Out(result, nil)
-	return nil
-}
-
-const (
-	driveMemberAddInvalidParameterCode = 1063001
-	driveMemberAddInvalidOperationCode = 1063003
-)
-
-func wrapDriveMemberAddBatchAPIError(err error) error {
-	var apiErr *errs.APIError
-	if !errors.As(err, &apiErr) {
-		return err
-	}
-
-	wrapped := *apiErr
-	switch apiErr.Code {
-	case driveMemberAddInvalidOperationCode:
-		wrapped.Message = "Drive batch member add failed: one or more requested members may already be collaborators on this resource"
-		wrapped.Hint = "For batch add, remove members that already have access (especially a bot/app being added again), then retry only the missing collaborators."
-	case driveMemberAddInvalidParameterCode:
-		wrapped.Message = "Drive batch member add failed: one or more requested members may be invalid for this resource or identity"
-		wrapped.Hint = "Check whether each --member-id exists, belongs to the same tenant, and is visible to the current identity; remove invalid members and retry only the valid collaborators."
-	default:
-		return err
-	}
-	wrapped.Cause = err
-	return &wrapped
-}
-
-func buildDriveMemberAddMemberBodies(spec driveMemberAddSpec) []map[string]interface{} {
-	members := make([]map[string]interface{}, len(spec.MemberIDs))
-	for i, mid := range spec.MemberIDs {
-		members[i] = buildMemberBody(mid, spec.MemberType, spec.MemberKind, spec.Perm, spec.PermType)
-	}
-	return members
-}
-
-func buildDriveMemberAddBatchResult(spec driveMemberAddSpec, data map[string]interface{}) map[string]interface{} {
-	rawMembers, _ := data["members"].([]interface{})
-
-	// Build set of requested IDs for O(1) lookup.
-	requestedSet := make(map[string]bool, len(spec.MemberIDs))
-	for _, id := range spec.MemberIDs {
-		requestedSet[id] = true
-	}
-
-	// First pass: build returned map and results array.
-	// Matching is done by member_id, not by array index, so the server may
-	// return members in any order without causing false partial_failure.
-	results := make([]map[string]interface{}, 0, len(rawMembers))
-	succeededIDs := make(map[string]bool, len(rawMembers))
-	var mismatched []map[string]interface{}
-
-	for _, raw := range rawMembers {
-		m, ok := raw.(map[string]interface{})
-		if !ok {
-			continue
-		}
-		rawMemberID := common.GetString(m, "member_id")
-
-		out := driveMemberAddOutputWithOptions(spec, "", m, false)
-		results = append(results, out)
-
-		if rawMemberID != "" {
-			if requestedSet[rawMemberID] {
-				succeededIDs[rawMemberID] = true
-			} else {
-				mismatched = append(mismatched, map[string]interface{}{
-					"returned": rawMemberID,
-				})
-			}
-		}
-	}
-
-	// Second pass: find requested IDs missing from the response.
-	missing := make([]string, 0)
-	for _, memberID := range spec.MemberIDs {
-		if !succeededIDs[memberID] {
-			missing = append(missing, memberID)
-		}
-	}
-
-	partial := len(results) != len(spec.MemberIDs) || len(missing) > 0 || len(mismatched) > 0
-	result := map[string]interface{}{
-		"resource_token":     spec.Token,
-		"resource_type":      spec.ResourceType,
-		"requested_count":    len(spec.MemberIDs),
-		"succeeded_count":    len(succeededIDs),
-		"partial":            partial,
-		"members":            results,
-		"missing_member_ids": missing,
-	}
-	if len(mismatched) > 0 {
-		result["mismatched_member_ids"] = mismatched
-	}
-	return result
-}
-
-// driveMemberAddOutput flattens the server response into a stable envelope and
-// backfills fields from spec when the server omits them.
-func driveMemberAddOutput(spec driveMemberAddSpec, fallbackMemberID string, raw map[string]interface{}) map[string]interface{} {
-	return driveMemberAddOutputWithOptions(spec, fallbackMemberID, raw, true)
-}
-
-func driveMemberAddOutputWithOptions(spec driveMemberAddSpec, fallbackMemberID string, raw map[string]interface{}, allowDefaultMemberID bool) map[string]interface{} {
-	out := map[string]interface{}{
-		"resource_token": spec.Token,
-		"resource_type":  spec.ResourceType,
-	}
-	if raw != nil {
-		for _, key := range []string{"member_id", "member_type", "perm", "type"} {
-			if v, ok := raw[key]; ok {
-				out[key] = v
-			}
-		}
-		if spec.ResourceType == "wiki" {
-			if v, ok := raw["perm_type"]; ok {
-				out["perm_type"] = v
-			}
-		}
-	}
-	if common.GetString(out, "member_id") == "" {
-		if fallbackMemberID == "" && allowDefaultMemberID && len(spec.MemberIDs) > 0 {
-			fallbackMemberID = spec.MemberIDs[0]
-		}
-		if fallbackMemberID != "" {
-			out["member_id"] = fallbackMemberID
-		}
-	}
-	if common.GetString(out, "member_type") == "" {
-		out["member_type"] = spec.MemberType
-	}
-	if common.GetString(out, "perm") == "" {
-		out["perm"] = spec.Perm
-	}
-	if spec.PermType != "" && common.GetString(out, "perm_type") == "" {
-		out["perm_type"] = spec.PermType
-	}
-	if bodyType := driveMemberAddBodyType(spec.MemberType, spec.MemberKind); bodyType != "" && common.GetString(out, "type") == "" {
-		out["type"] = bodyType
-	}
-	if t := common.GetString(out, "type"); t != "" {
-		out["member_kind"] = t
-	}
-	delete(out, "type")
-	return out
-}

shortcuts/drive/shortcuts.go

@@ -30,7 +30,6 @@ func Shortcuts() []common.Shortcut {
 		DriveSync,
 		DriveTaskResult,
 		DriveApplyPermission,
-		DriveMemberAdd,
 		DriveSecureLabelList,
 		DriveSecureLabelUpdate,
 		DriveSearch,

shortcuts/drive/shortcuts_test.go

@@ -33,7 +33,6 @@ func TestShortcutsIncludesExpectedCommands(t *testing.T) {
 		"+sync",
 		"+task_result",
 		"+apply-permission",
-		"+member-add",
 		"+secure-label-list",
 		"+secure-label-update",
 		"+search",

shortcuts/minutes/minutes_detail.go

@@ -1,320 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-//
-// minutes +detail — query minute details with selective artifact flags
-
-package minutes
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"io"
-	"net/http"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"time"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/extension/fileio"
-	"github.com/larksuite/cli/internal/auth"
-	"github.com/larksuite/cli/internal/credential"
-	"github.com/larksuite/cli/internal/output"
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-const minutesDetailLogPrefix = "[minutes +detail]"
-
-// Error codes from the minutes API.
-const minutesDetailNoReadPermissionCode = 2091005
-
-var validMinuteTokenDetail = regexp.MustCompile(`^[a-z0-9]+$`)
-
-var scopesDetailMinuteTokens = []string{
-	"minutes:minutes.basic:read",
-	"minutes:minutes.artifacts:read",
-}
-
-// minuteDetailItem represents a single minute detail result.
-type minuteDetailItem struct {
-	MinuteToken string         `json:"minute_token"`
-	Title       string         `json:"title"`
-	NoteID      string         `json:"note_id"`
-	Artifacts   map[string]any `json:"artifacts,omitempty"`
-	Error       string         `json:"error,omitempty"`
-}
-
-// fetchMinuteDetail queries a single minute's metadata and selected artifacts.
-func fetchMinuteDetail(ctx context.Context, runtime *common.RuntimeContext, minuteToken string) *minuteDetailItem {
-	data, err := runtime.CallAPITyped(http.MethodGet,
-		fmt.Sprintf("/open-apis/minutes/v1/minutes/%s", validate.EncodePathSegment(minuteToken)), nil, nil)
-	if err != nil {
-		result := &minuteDetailItem{MinuteToken: minuteToken}
-		if p, ok := errs.ProblemOf(err); ok && p.Code == minutesDetailNoReadPermissionCode {
-			result.Error = fmt.Sprintf("No read permission for minute %s. Ask the minute owner for minute file read permission", minuteToken)
-		} else {
-			result.Error = fmt.Sprintf("failed to query minute: %v", err)
-		}
-		return result
-	}
-
-	minute, _ := data["minute"].(map[string]any)
-	if minute == nil {
-		return &minuteDetailItem{MinuteToken: minuteToken, Error: "minute not found"}
-	}
-
-	result := &minuteDetailItem{MinuteToken: minuteToken}
-	if v, ok := minute["title"].(string); ok && v != "" {
-		result.Title = v
-	}
-	if v, ok := minute["note_id"].(string); ok && v != "" {
-		result.NoteID = v
-	}
-
-	// Fetch artifacts selectively based on flags
-	needSummary := runtime.Bool("summary")
-	needTodo := runtime.Bool("todo")
-	needChapter := runtime.Bool("chapter")
-	needTranscript := runtime.Bool("transcript")
-	needKeyword := runtime.Bool("keyword")
-
-	if needSummary || needTodo || needChapter || needTranscript || needKeyword {
-		artData, err := runtime.CallAPITyped(http.MethodGet,
-			fmt.Sprintf("/open-apis/minutes/v1/minutes/%s/artifacts", validate.EncodePathSegment(minuteToken)), nil, nil)
-		if err != nil {
-			fmt.Fprintf(runtime.IO().ErrOut, "%s failed to fetch artifacts for %s: %v\n", minutesDetailLogPrefix, minuteToken, err)
-		} else {
-			artifacts := make(map[string]any)
-			if needSummary {
-				if v, ok := artData["summary"].(string); ok && v != "" {
-					artifacts["summary"] = v
-				} else {
-					artifacts["summary"] = ""
-				}
-			}
-			if needTodo {
-				if v, ok := artData["minute_todos"].([]any); ok && len(v) > 0 {
-					artifacts["todos"] = v
-				} else {
-					artifacts["todos"] = []any{}
-				}
-			}
-			if needChapter {
-				if v, ok := artData["minute_chapters"].([]any); ok && len(v) > 0 {
-					artifacts["chapters"] = v
-				} else {
-					artifacts["chapters"] = []any{}
-				}
-			}
-			if needKeyword {
-				if v, ok := artData["keywords"].([]any); ok && len(v) > 0 {
-					artifacts["keywords"] = v
-				} else {
-					artifacts["keywords"] = []any{}
-				}
-			}
-			if needTranscript {
-				if v, ok := artData["transcript"].(string); ok && v != "" {
-					if path := saveDetailTranscript(runtime, minuteToken, result.Title, []byte(v)); path != "" {
-						artifacts["transcript_file"] = path
-					} else {
-						artifacts["transcript_file"] = ""
-					}
-				} else {
-					artifacts["transcript_file"] = ""
-				}
-			}
-			result.Artifacts = artifacts
-		}
-	}
-
-	return result
-}
-
-// saveDetailTranscript persists transcript bytes to the canonical artifact path.
-// With --output-dir, transcripts land under <output-dir>/artifact-<title>-<token>/
-// to mirror the legacy `vc +notes` layout. Otherwise falls back to the default
-// ./minutes/<token>/ shared with `minutes +download`.
-func saveDetailTranscript(runtime *common.RuntimeContext, minuteToken, title string, content []byte) string {
-	errOut := runtime.IO().ErrOut
-	var dirName string
-	if outDir := runtime.Str("output-dir"); outDir != "" {
-		dirName = filepath.Join(outDir, sanitizeDetailDirName(title, minuteToken))
-	} else {
-		dirName = common.DefaultMinuteArtifactDir(minuteToken)
-	}
-	transcriptPath := filepath.Join(dirName, common.DefaultTranscriptFileName)
-
-	if !runtime.Bool("overwrite") {
-		if _, statErr := runtime.FileIO().Stat(transcriptPath); statErr == nil {
-			fmt.Fprintf(errOut, "%s transcript already exists: %s (use --overwrite to replace)\n", minutesDetailLogPrefix, transcriptPath)
-			return transcriptPath
-		}
-	}
-
-	fmt.Fprintf(errOut, "%s writing transcript: %s\n", minutesDetailLogPrefix, transcriptPath)
-	if _, err := runtime.FileIO().Save(transcriptPath, fileio.SaveOptions{}, bytes.NewReader(content)); err != nil {
-		fmt.Fprintf(errOut, "%s failed to write transcript: %v\n", minutesDetailLogPrefix, err)
-		return ""
-	}
-	return transcriptPath
-}
-
-// sanitizeDetailDirName generates a filesystem-safe directory name using title
-// and minuteToken for uniqueness. Mirrors the layout produced by `vc +notes`
-// so both shortcuts write artifacts to identical paths under --output-dir.
-func sanitizeDetailDirName(title, minuteToken string) string {
-	const maxLen = 200
-	replacer := strings.NewReplacer(
-		"/", "_", "\\", "_", ":", "_", "*", "_", "?", "_",
-		"\"", "_", "<", "_", ">", "_", "|", "_",
-		"\n", "_", "\r", "_", "\t", "_", "\x00", "_",
-	)
-	safe := replacer.Replace(strings.TrimSpace(title))
-	safe = strings.Trim(safe, ".")
-	if len(safe) > maxLen {
-		safe = safe[:maxLen]
-	}
-	if safe == "" {
-		return fmt.Sprintf("artifact-%s", minuteToken)
-	}
-	return fmt.Sprintf("artifact-%s-%s", safe, minuteToken)
-}
-
-// MinutesDetail queries minute details with selective artifact flags.
-var MinutesDetail = common.Shortcut{
-	Service:     "minutes",
-	Command:     "+detail",
-	Description: "Query minute details with selective artifact flags (summary, todo, chapter, transcript, keyword)",
-	Risk:        "read",
-	Scopes:      []string{"minutes:minutes.basic:read", "minutes:minutes.artifacts:read"},
-	AuthTypes:   []string{"user"},
-	HasFormat:   true,
-	Flags: []common.Flag{
-		{Name: "minute-tokens", Desc: "minute tokens, comma-separated for batch", Required: true},
-		{Name: "summary", Type: "bool", Desc: "include summary"},
-		{Name: "todo", Type: "bool", Desc: "include todos"},
-		{Name: "chapter", Type: "bool", Desc: "include chapters"},
-		{Name: "transcript", Type: "bool", Desc: "include transcript (saved to file)"},
-		{Name: "keyword", Type: "bool", Desc: "include keywords"},
-		{Name: "output-dir", Desc: "output directory for transcript files (default: ./minutes/{minute_token}/)"},
-		{Name: "overwrite", Type: "bool", Desc: "overwrite existing transcript files"},
-	},
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		tokens := common.SplitCSV(runtime.Str("minute-tokens"))
-		const maxBatchSize = 50
-		if len(tokens) > maxBatchSize {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--minute-tokens: too many tokens (%d), maximum is %d", len(tokens), maxBatchSize).WithParam("--minute-tokens")
-		}
-		for _, token := range tokens {
-			if !validMinuteTokenDetail.MatchString(token) {
-				return errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid minute token %q: must contain only lowercase alphanumeric characters", token).WithParam("--minute-tokens")
-			}
-		}
-		if outDir := runtime.Str("output-dir"); outDir != "" {
-			if err := common.ValidateSafePathTyped(runtime.FileIO(), outDir); err != nil {
-				return err
-			}
-		}
-		// dynamic scope check
-		result, err := runtime.Factory.Credential.ResolveToken(ctx, credential.NewTokenSpec(runtime.As(), runtime.Config.AppID))
-		if err == nil && result != nil && result.Scopes != "" {
-			if missing := auth.MissingScopes(result.Scopes, scopesDetailMinuteTokens); len(missing) > 0 {
-				return errs.NewPermissionError(errs.SubtypeMissingScope,
-					"missing required scope(s): %s", strings.Join(missing, ", ")).
-					WithHint("run `lark-cli auth login --scope %q` in the background. It blocks and outputs a verification URL — retrieve the URL and open it in a browser to complete login.", strings.Join(missing, " ")).
-					WithMissingScopes(missing...).
-					WithIdentity(string(runtime.As()))
-			}
-		}
-		return nil
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		tokens := runtime.Str("minute-tokens")
-		d := common.NewDryRunAPI().
-			GET("/open-apis/minutes/v1/minutes/{minute_token}").
-			Set("minute_tokens", common.SplitCSV(tokens))
-
-		if runtime.Bool("summary") || runtime.Bool("todo") || runtime.Bool("chapter") || runtime.Bool("transcript") || runtime.Bool("keyword") {
-			d.GET("/open-apis/minutes/v1/minutes/{minute_token}/artifacts")
-		}
-		return d
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		errOut := runtime.IO().ErrOut
-		minuteTokens := common.SplitCSV(runtime.Str("minute-tokens"))
-		results := make([]*minuteDetailItem, 0, len(minuteTokens))
-
-		const batchDelay = 100 * time.Millisecond
-		fmt.Fprintf(errOut, "%s querying %d minute_token(s)\n", minutesDetailLogPrefix, len(minuteTokens))
-		for i, token := range minuteTokens {
-			if err := ctx.Err(); err != nil {
-				return err
-			}
-			if i > 0 {
-				time.Sleep(batchDelay)
-			}
-			fmt.Fprintf(errOut, "%s querying minute_token=%s ...\n", minutesDetailLogPrefix, token)
-			results = append(results, fetchMinuteDetail(ctx, runtime, token))
-		}
-
-		successCount := 0
-		for _, r := range results {
-			if r.Error == "" {
-				successCount++
-			}
-		}
-		fmt.Fprintf(errOut, "%s done: %d total, %d succeeded, %d failed\n", minutesDetailLogPrefix, len(results), successCount, len(results)-successCount)
-
-		if successCount == 0 && len(results) > 0 {
-			return runtime.OutPartialFailure(map[string]any{"minutes": results}, &output.Meta{Count: len(results)})
-		}
-
-		outData := map[string]any{"minutes": results}
-		runtime.OutFormat(outData, &output.Meta{Count: len(results)}, func(w io.Writer) {
-			if len(results) == 0 {
-				fmt.Fprintln(w, "No minutes.")
-				return
-			}
-			var rows []map[string]interface{}
-			for _, r := range results {
-				row := map[string]interface{}{"minute_token": r.MinuteToken}
-				if r.Error != "" {
-					row["status"] = "FAIL"
-					row["error"] = r.Error
-				} else {
-					row["status"] = "OK"
-					row["title"] = r.Title
-					row["note_id"] = r.NoteID
-					if len(r.Artifacts) > 0 {
-						var parts []string
-						if _, ok := r.Artifacts["summary"]; ok {
-							parts = append(parts, "summary")
-						}
-						if _, ok := r.Artifacts["todos"]; ok {
-							parts = append(parts, "todo")
-						}
-						if _, ok := r.Artifacts["chapters"]; ok {
-							parts = append(parts, "chapter")
-						}
-						if _, ok := r.Artifacts["keywords"]; ok {
-							parts = append(parts, "keyword")
-						}
-						if _, ok := r.Artifacts["transcript_file"]; ok {
-							parts = append(parts, "transcript")
-						}
-						if len(parts) > 0 {
-							row["artifacts"] = strings.Join(parts, ", ")
-						}
-					}
-				}
-				rows = append(rows, row)
-			}
-			output.PrintTable(w, rows)
-			fmt.Fprintf(w, "\n%d minute(s), %d succeeded, %d failed\n", len(results), successCount, len(results)-successCount)
-		})
-		return nil
-	},
-}

shortcuts/minutes/minutes_detail_test.go

@@ -1,394 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package minutes
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-	"strings"
-	"sync"
-	"testing"
-
-	"github.com/spf13/cobra"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/httpmock"
-	"github.com/larksuite/cli/internal/output"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// ---------------------------------------------------------------------------
-// helpers
-// ---------------------------------------------------------------------------
-
-var detailWarmOnce sync.Once
-
-func detailWarmTokenCache(t *testing.T) {
-	t.Helper()
-	detailWarmOnce.Do(func() {
-		f, _, _, reg := cmdutil.TestFactory(t, defaultConfig())
-		reg.Register(&httpmock.Stub{
-			URL:  "/open-apis/test/v1/warm",
-			Body: map[string]interface{}{"code": 0, "msg": "ok", "data": map[string]interface{}{}},
-		})
-		s := common.Shortcut{
-			Service:   "test",
-			Command:   "+warm",
-			AuthTypes: []string{"bot"},
-			Execute: func(_ context.Context, rctx *common.RuntimeContext) error {
-				_, err := rctx.CallAPITyped("GET", "/open-apis/test/v1/warm", nil, nil)
-				return err
-			},
-		}
-		parent := &cobra.Command{Use: "test"}
-		s.Mount(parent, f)
-		parent.SetArgs([]string{"+warm"})
-		parent.SilenceErrors = true
-		parent.SilenceUsage = true
-		parent.Execute()
-	})
-}
-
-func detailMountAndRun(t *testing.T, s common.Shortcut, args []string, f *cmdutil.Factory, stdout *bytes.Buffer) error {
-	t.Helper()
-	detailWarmTokenCache(t)
-	parent := &cobra.Command{Use: "minutes"}
-	s.Mount(parent, f)
-	parent.SetArgs(args)
-	parent.SilenceErrors = true
-	parent.SilenceUsage = true
-	if stdout != nil {
-		stdout.Reset()
-	}
-	return parent.Execute()
-}
-
-// ---------------------------------------------------------------------------
-// Validation tests
-// ---------------------------------------------------------------------------
-
-func detailMinuteGetStub(token, noteID, title string) *httpmock.Stub {
-	minute := map[string]interface{}{"title": title}
-	if noteID != "" {
-		minute["note_id"] = noteID
-	}
-	return &httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/minutes/v1/minutes/" + token,
-		Body: map[string]interface{}{
-			"code": 0, "msg": "ok",
-			"data": map[string]interface{}{"minute": minute},
-		},
-	}
-}
-
-func detailArtifactsStub(token, transcript string) *httpmock.Stub {
-	data := map[string]interface{}{
-		"summary":         "Test summary content",
-		"minute_todos":    []interface{}{map[string]interface{}{"content": "Buy milk"}},
-		"minute_chapters": []interface{}{map[string]interface{}{"title": "Intro", "summary_content": "Opening"}},
-		"keywords":        []interface{}{"budget", "roadmap"},
-	}
-	if transcript != "" {
-		data["transcript"] = transcript
-	}
-	return &httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/minutes/v1/minutes/" + token + "/artifacts",
-		Body: map[string]interface{}{
-			"code": 0, "msg": "ok",
-			"data": data,
-		},
-	}
-}
-
-func TestDetail_Validation_MissingMinuteTokens(t *testing.T) {
-	f, _, _, _ := cmdutil.TestFactory(t, defaultConfig())
-	err := detailMountAndRun(t, MinutesDetail, []string{"+detail", "--as", "user"}, f, nil)
-	if err == nil {
-		t.Fatal("expected validation error for missing --minute-tokens")
-	}
-}
-
-func TestDetail_Validation_InvalidToken(t *testing.T) {
-	f, _, _, _ := cmdutil.TestFactory(t, defaultConfig())
-	err := detailMountAndRun(t, MinutesDetail, []string{"+detail", "--minute-tokens", "INVALID!", "--as", "user"}, f, nil)
-	if err == nil {
-		t.Fatal("expected validation error for invalid token")
-	}
-	var ve *errs.ValidationError
-	if !errors.As(err, &ve) {
-		t.Fatalf("expected *errs.ValidationError, got %T: %v", err, err)
-	}
-	if ve.Param != "--minute-tokens" {
-		t.Errorf("Param = %q, want --minute-tokens", ve.Param)
-	}
-}
-
-func TestDetail_Validation_BatchLimit(t *testing.T) {
-	f, _, _, _ := cmdutil.TestFactory(t, defaultConfig())
-	tokens := make([]string, 51)
-	for i := range tokens {
-		tokens[i] = fmt.Sprintf("tok%d", i)
-	}
-	err := detailMountAndRun(t, MinutesDetail, []string{"+detail", "--minute-tokens", strings.Join(tokens, ","), "--as", "user"}, f, nil)
-	if err == nil {
-		t.Fatal("expected batch limit error")
-	}
-	if !strings.Contains(err.Error(), "too many tokens") {
-		t.Errorf("expected 'too many tokens' error, got: %v", err)
-	}
-}
-
-// ---------------------------------------------------------------------------
-// DryRun tests
-// ---------------------------------------------------------------------------
-
-func TestDetail_DryRun(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, defaultConfig())
-	err := detailMountAndRun(t, MinutesDetail, []string{"+detail", "--minute-tokens", "tok001", "--dry-run", "--as", "user"}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !strings.Contains(stdout.String(), "/open-apis/minutes/v1/minutes/") {
-		t.Errorf("dry-run should show minutes API path, got: %s", stdout.String())
-	}
-}
-
-func TestDetail_DryRun_WithArtifactFlags(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, defaultConfig())
-	err := detailMountAndRun(t, MinutesDetail, []string{"+detail", "--minute-tokens", "tok001", "--summary", "--todo", "--dry-run", "--as", "user"}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !strings.Contains(stdout.String(), "artifacts") {
-		t.Errorf("dry-run should show artifacts API path when artifact flags are set, got: %s", stdout.String())
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Execute tests with mocked HTTP
-// ---------------------------------------------------------------------------
-
-func TestDetail_Execute_BasicInfo(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, defaultConfig())
-	reg.Register(detailMinuteGetStub("tokbasic", "", "Test Meeting"))
-
-	err := detailMountAndRun(t, MinutesDetail, []string{"+detail", "--minute-tokens", "tokbasic", "--as", "user"}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	var resp map[string]any
-	if err := json.Unmarshal(stdout.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to parse output: %v", err)
-	}
-	data, _ := resp["data"].(map[string]any)
-	minutes, _ := data["minutes"].([]any)
-	if len(minutes) != 1 {
-		t.Fatalf("expected 1 minute, got %d", len(minutes))
-	}
-	m, _ := minutes[0].(map[string]any)
-	if m["minute_token"] != "tokbasic" {
-		t.Errorf("minute_token = %v, want tokbasic", m["minute_token"])
-	}
-	if m["title"] != "Test Meeting" {
-		t.Errorf("title = %v, want Test Meeting", m["title"])
-	}
-	noteID, hasNoteID := m["note_id"]
-	if !hasNoteID {
-		t.Error("note_id should always be present in output (even when empty)")
-	}
-	if noteID != "" {
-		t.Errorf("note_id should be empty string when minute has no note_id, got %v", noteID)
-	}
-}
-
-func TestDetail_Execute_WithSummaryAndTodo(t *testing.T) {
-	chdirForDetailTest(t)
-
-	f, stdout, _, reg := cmdutil.TestFactory(t, defaultConfig())
-	reg.Register(detailMinuteGetStub("tokart", "note_art", "Artifact Meeting"))
-	reg.Register(detailArtifactsStub("tokart", ""))
-
-	err := detailMountAndRun(t, MinutesDetail, []string{"+detail", "--minute-tokens", "tokart", "--summary", "--todo", "--as", "user"}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	var resp map[string]any
-	if err := json.Unmarshal(stdout.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to parse output: %v", err)
-	}
-	data, _ := resp["data"].(map[string]any)
-	minutes, _ := data["minutes"].([]any)
-	if len(minutes) != 1 {
-		t.Fatalf("expected 1 minute, got %d", len(minutes))
-	}
-	m, _ := minutes[0].(map[string]any)
-	if m["note_id"] != "note_art" {
-		t.Errorf("note_id = %v, want note_art", m["note_id"])
-	}
-	arts, _ := m["artifacts"].(map[string]any)
-	if arts == nil {
-		t.Fatal("expected artifacts to be present")
-	}
-	if _, ok := arts["summary"]; !ok {
-		t.Error("expected summary in artifacts")
-	}
-	if _, ok := arts["todos"]; !ok {
-		t.Error("expected todos in artifacts")
-	}
-	// chapter and keywords should NOT be present since flags not set
-	if _, ok := arts["chapters"]; ok {
-		t.Error("chapters should not be present when --chapter not set")
-	}
-	if _, ok := arts["keywords"]; ok {
-		t.Error("keywords should not be present when --keyword not set")
-	}
-}
-
-func TestDetail_Execute_NoArtifactFlags(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, defaultConfig())
-	reg.Register(detailMinuteGetStub("toknoart", "", "No Artifacts"))
-
-	err := detailMountAndRun(t, MinutesDetail, []string{"+detail", "--minute-tokens", "toknoart", "--as", "user"}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	var resp map[string]any
-	if err := json.Unmarshal(stdout.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to parse output: %v", err)
-	}
-	data, _ := resp["data"].(map[string]any)
-	minutes, _ := data["minutes"].([]any)
-	if len(minutes) != 1 {
-		t.Fatalf("expected 1 minute, got %d", len(minutes))
-	}
-	m, _ := minutes[0].(map[string]any)
-	if _, ok := m["artifacts"]; ok {
-		t.Error("artifacts should not be present when no artifact flags set")
-	}
-}
-
-func TestDetail_Execute_Transcript(t *testing.T) {
-	chdirForDetailTest(t)
-
-	f, stdout, _, reg := cmdutil.TestFactory(t, defaultConfig())
-	reg.Register(detailMinuteGetStub("toktrans", "", "Transcript Meeting"))
-	reg.Register(detailArtifactsStub("toktrans", "speaker1: hello world\n"))
-
-	err := detailMountAndRun(t, MinutesDetail, []string{"+detail", "--minute-tokens", "toktrans", "--transcript", "--as", "user"}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	// Check transcript file was saved
-	wantPath := "minutes/toktrans/transcript.txt"
-	data, err := os.ReadFile(wantPath)
-	if err != nil {
-		t.Fatalf("expected file at %s: %v", wantPath, err)
-	}
-	if string(data) != "speaker1: hello world\n" {
-		t.Errorf("content mismatch: %q", string(data))
-	}
-}
-
-func TestDetail_Execute_Transcript_OutputDir(t *testing.T) {
-	chdirForDetailTest(t)
-
-	f, stdout, _, reg := cmdutil.TestFactory(t, defaultConfig())
-	reg.Register(detailMinuteGetStub("tokod", "", "Output Dir Meeting"))
-	reg.Register(detailArtifactsStub("tokod", "alice: hi\n"))
-
-	err := detailMountAndRun(t, MinutesDetail, []string{"+detail", "--minute-tokens", "tokod", "--transcript", "--output-dir", "custom_out", "--as", "user"}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	// Mirrors `minutes +detail --output-dir` layout: artifact-<title>-<token>/transcript.txt
-	wantPath := "custom_out/artifact-Output Dir Meeting-tokod/transcript.txt"
-	data, err := os.ReadFile(wantPath)
-	if err != nil {
-		t.Fatalf("expected file at %s: %v", wantPath, err)
-	}
-	if string(data) != "alice: hi\n" {
-		t.Errorf("content mismatch: %q", string(data))
-	}
-}
-
-func TestDetail_Validation_OutputDirEscape(t *testing.T) {
-	chdirForDetailTest(t)
-	f, _, _, _ := cmdutil.TestFactory(t, defaultConfig())
-	err := detailMountAndRun(t, MinutesDetail, []string{"+detail", "--minute-tokens", "tok001", "--output-dir", "../escape", "--as", "user"}, f, nil)
-	if err == nil {
-		t.Fatal("expected validation error for escaping output-dir")
-	}
-	var ve *errs.ValidationError
-	if !errors.As(err, &ve) {
-		t.Fatalf("expected *errs.ValidationError, got %T: %v", err, err)
-	}
-}
-
-func TestDetail_Execute_MinuteNotFound(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, defaultConfig())
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/minutes/v1/minutes/tokbad",
-		Body:   map[string]interface{}{"code": 2091004, "msg": "not found"},
-	})
-
-	err := detailMountAndRun(t, MinutesDetail, []string{"+detail", "--minute-tokens", "tokbad", "--as", "user"}, f, stdout)
-	if err == nil {
-		t.Fatal("expected partial failure error")
-	}
-	var pfErr *output.PartialFailureError
-	if !errors.As(err, &pfErr) {
-		t.Fatalf("expected *output.PartialFailureError, got %T: %v", err, err)
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Pure function tests
-// ---------------------------------------------------------------------------
-
-func TestValidMinuteTokenDetail(t *testing.T) {
-	tests := []struct {
-		token string
-		valid bool
-	}{
-		{"abc123", true},
-		{"obcnmgn1429t5xt9j82i1p3h", true},
-		{"INVALID!", false},
-		{"has-space", false},
-		{"", false},
-	}
-	for _, tt := range tests {
-		got := validMinuteTokenDetail.MatchString(tt.token)
-		if got != tt.valid {
-			t.Errorf("validMinuteTokenDetail(%q) = %v, want %v", tt.token, got, tt.valid)
-		}
-	}
-}
-
-// chdirForDetailTest switches cwd to a temp dir for the test.
-func chdirForDetailTest(t *testing.T) string {
-	t.Helper()
-	orig, err := os.Getwd()
-	if err != nil {
-		t.Fatalf("getwd: %v", err)
-	}
-	dir := t.TempDir()
-	if err := os.Chdir(dir); err != nil {
-		t.Fatalf("chdir: %v", err)
-	}
-	t.Cleanup(func() { os.Chdir(orig) })
-	return dir
-}

shortcuts/minutes/minutes_search.go

@@ -184,6 +184,12 @@ func minuteSearchAppLink(item map[string]interface{}) string {
 	return common.GetString(meta, "app_link")
 }
 
+// minuteSearchAvatar extracts the avatar URL from a search result item.
+func minuteSearchAvatar(item map[string]interface{}) string {
+	meta := common.GetMap(item, "meta_data")
+	return common.GetString(meta, "avatar")
+}
+
 // buildMinuteSearchRows converts API items into pretty output rows.
 func buildMinuteSearchRows(items []interface{}) []map[string]interface{} {
 	rows := make([]map[string]interface{}, 0, len(items))
@@ -197,27 +203,12 @@ func buildMinuteSearchRows(items []interface{}) []map[string]interface{} {
 			"display_info": common.TruncateStr(minuteSearchDisplayInfo(item), 40),
 			"description":  common.TruncateStr(minuteSearchDescription(item), 40),
 			"app_link":     common.TruncateStr(minuteSearchAppLink(item), 80),
+			"avatar":       common.TruncateStr(minuteSearchAvatar(item), 80),
 		})
 	}
 	return rows
 }
 
-// stripAvatarFromItems removes meta_data.avatar from each search item in place
-// so the structured output does not surface avatars to AI agents.
-func stripAvatarFromItems(items []interface{}) {
-	for _, raw := range items {
-		item, _ := raw.(map[string]interface{})
-		if item == nil {
-			continue
-		}
-		meta, _ := item["meta_data"].(map[string]interface{})
-		if meta == nil {
-			continue
-		}
-		delete(meta, "avatar")
-	}
-}
-
 // MinutesSearch searches minutes by keyword, owners, participants, and time range.
 var MinutesSearch = common.Shortcut{
 	Service:     "minutes",
@@ -307,13 +298,13 @@ var MinutesSearch = common.Shortcut{
 		}
 
 		items := minuteSearchItems(data)
-		stripAvatarFromItems(items)
 		hasMore, _ := data["has_more"].(bool)
 		pageToken, _ := data["page_token"].(string)
 		rows := buildMinuteSearchRows(items)
 
 		outData := map[string]interface{}{
 			"items":      items,
+			"total":      data["total"],
 			"has_more":   data["has_more"],
 			"page_token": data["page_token"],
 		}

shortcuts/minutes/minutes_search_test.go

@@ -526,7 +526,7 @@ func TestMinutesSearchExecuteRendersRowsAndMoreHint(t *testing.T) {
 	}
 
 	out := stdout.String()
-	for _, want := range []string{"minute_1", "周会摘要", "周会纪要", "https://meetings.feishu.cn/minutes/obcn123", "next_token", "more available"} {
+	for _, want := range []string{"minute_1", "周会摘要", "周会纪要", "https://meetings.feishu.cn/minutes/obcn123", "https://p3-lark-file.byteimg.com/img/xxxx.jpg", "next_token", "more available"} {
 		if !strings.Contains(out, want) {
 			t.Fatalf("output missing %q, got: %s", want, out)
 		}
@@ -672,6 +672,7 @@ func TestMinuteSearchFieldExtractors(t *testing.T) {
 		"meta_data": map[string]interface{}{
 			"description": "周会纪要",
 			"app_link":    "https://meetings.feishu.cn/minutes/obcn123",
+			"avatar":      "https://p3-lark-file.byteimg.com/img/xxxx.jpg",
 		},
 	}
 
@@ -687,6 +688,9 @@ func TestMinuteSearchFieldExtractors(t *testing.T) {
 	if got := minuteSearchAppLink(item); got != "https://meetings.feishu.cn/minutes/obcn123" {
 		t.Fatalf("minuteSearchAppLink() = %q", got)
 	}
+	if got := minuteSearchAvatar(item); got != "https://p3-lark-file.byteimg.com/img/xxxx.jpg" {
+		t.Fatalf("minuteSearchAvatar() = %q", got)
+	}
 }
 
 // TestMinuteSearchFieldExtractorsFallbacks verifies extractors keep working for alternate sample data.
@@ -699,6 +703,7 @@ func TestMinuteSearchFieldExtractorsFallbacks(t *testing.T) {
 		"meta_data": map[string]interface{}{
 			"description": "回退纪要",
 			"app_link":    "https://meetings.feishu.cn/minutes/fallback",
+			"avatar":      "https://p3-lark-file.byteimg.com/img/fallback.jpg",
 		},
 	}
 
@@ -711,6 +716,9 @@ func TestMinuteSearchFieldExtractorsFallbacks(t *testing.T) {
 	if got := minuteSearchAppLink(item); got != "https://meetings.feishu.cn/minutes/fallback" {
 		t.Fatalf("minuteSearchAppLink() = %q", got)
 	}
+	if got := minuteSearchAvatar(item); got != "https://p3-lark-file.byteimg.com/img/fallback.jpg" {
+		t.Fatalf("minuteSearchAvatar() = %q", got)
+	}
 }
 
 // TestMinuteSearchFieldExtractorsMissingMetaData verifies extractors fall back to empty values without metadata.
@@ -731,32 +739,7 @@ func TestMinuteSearchFieldExtractorsMissingMetaData(t *testing.T) {
 	if got := minuteSearchAppLink(item); got != "" {
 		t.Fatalf("minuteSearchAppLink() = %q, want empty", got)
 	}
-}
-
-// TestStripAvatarFromItems verifies the avatar field is removed from items in place.
-func TestStripAvatarFromItems(t *testing.T) {
-	t.Parallel()
-
-	items := []interface{}{
-		map[string]interface{}{
-			"token": "minute_1",
-			"meta_data": map[string]interface{}{
-				"description": "周会纪要",
-				"avatar":      "https://p3-lark-file.byteimg.com/img/xxxx.jpg",
-			},
-		},
-		nil,
-		map[string]interface{}{"token": "minute_no_meta"},
-	}
-
-	stripAvatarFromItems(items)
-
-	first, _ := items[0].(map[string]interface{})
-	meta, _ := first["meta_data"].(map[string]interface{})
-	if _, ok := meta["avatar"]; ok {
-		t.Fatalf("avatar should be stripped, got meta = %v", meta)
-	}
-	if meta["description"] != "周会纪要" {
-		t.Fatalf("description should be preserved, got %v", meta["description"])
+	if got := minuteSearchAvatar(item); got != "" {
+		t.Fatalf("minuteSearchAvatar() = %q, want empty", got)
 	}
 }

shortcuts/minutes/minutes_speaker_replace.go

@@ -25,13 +25,12 @@ var MinutesSpeakerReplace = common.Shortcut{
 	Command:     "+speaker-replace",
 	Description: "Replace a speaker in a minute's transcript (rebind from one user to another)",
 	Risk:        "write",
-	Scopes:      []string{"minutes:minutes:readonly", "minutes:minutes:update"},
+	Scopes:      []string{"minutes:minutes:update"},
 	AuthTypes:   []string{"user"},
 	HasFormat:   true,
 	Flags: []common.Flag{
 		{Name: "minute-token", Desc: "minute token", Required: true},
-		{Name: "from-speaker-id", Desc: "speaker to replace: opaque speaker_id from transcript speakerlist API (do not pass display names)"},
-		{Name: "from-user-id", Desc: "deprecated: open_id of the speaker to replace; prefer --from-speaker-id", Hidden: true},
+		{Name: "from-user-id", Desc: "speaker to replace, must be an open_id starting with 'ou_'", Required: true},
 		{Name: "to-user-id", Desc: "new speaker, must be an open_id starting with 'ou_'", Required: true},
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
@@ -42,10 +41,12 @@ var MinutesSpeakerReplace = common.Shortcut{
 		if err := validate.ResourceName(minuteToken, "--minute-token"); err != nil {
 			return errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err).WithParam("--minute-token")
 		}
-		fromSpeakerID := strings.TrimSpace(runtime.Str("from-speaker-id"))
 		fromUserID := strings.TrimSpace(runtime.Str("from-user-id"))
-		if fromSpeakerID == "" && fromUserID == "" {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--from-speaker-id is required").WithParam("--from-speaker-id")
+		if fromUserID == "" {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--from-user-id is required").WithParam("--from-user-id")
+		}
+		if _, err := common.ValidateUserIDTyped("--from-user-id", fromUserID); err != nil {
+			return err
 		}
 		toUserID := strings.TrimSpace(runtime.Str("to-user-id"))
 		if toUserID == "" {
@@ -54,93 +55,53 @@ var MinutesSpeakerReplace = common.Shortcut{
 		if _, err := common.ValidateUserIDTyped("--to-user-id", toUserID); err != nil {
 			return err
 		}
-		if fromSpeakerID == "" {
-			if _, err := common.ValidateUserIDTyped("--from-user-id", fromUserID); err != nil {
-				return err
-			}
-			if fromUserID == toUserID {
-				return errs.NewValidationError(errs.SubtypeInvalidArgument, "--from-user-id and --to-user-id must be different").WithParam("--to-user-id")
-			}
+		if fromUserID == toUserID {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--from-user-id and --to-user-id must be different").WithParam("--to-user-id")
 		}
 		return nil
 	},
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
 		minuteToken := strings.TrimSpace(runtime.Str("minute-token"))
-		dr := common.NewDryRunAPI()
-		if strings.TrimSpace(runtime.Str("from-speaker-id")) != "" && strings.TrimSpace(runtime.Str("from-user-id")) == "" {
-			dr.GET(minuteTranscriptSpeakerlistPath(minuteToken)).Desc("Resolve --from-speaker-id when it is a display name")
-		}
-		return dr.PUT(fmt.Sprintf("/open-apis/minutes/v1/minutes/%s/transcript/speaker", validate.EncodePathSegment(minuteToken))).
-			Body(buildSpeakerReplaceRequestBody(runtime))
+		fromUserID := strings.TrimSpace(runtime.Str("from-user-id"))
+		toUserID := strings.TrimSpace(runtime.Str("to-user-id"))
+		return common.NewDryRunAPI().
+			PUT(fmt.Sprintf("/open-apis/minutes/v1/minutes/%s/transcript/speaker", validate.EncodePathSegment(minuteToken))).
+			Body(map[string]interface{}{
+				"minute_token": minuteToken,
+				"from_user_id": fromUserID,
+				"to_user_id":   toUserID,
+			})
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
 		minuteToken := strings.TrimSpace(runtime.Str("minute-token"))
-		fromSpeakerInput := strings.TrimSpace(runtime.Str("from-speaker-id"))
+		fromUserID := strings.TrimSpace(runtime.Str("from-user-id"))
 		toUserID := strings.TrimSpace(runtime.Str("to-user-id"))
 
-		fromSpeakerID, fromUserID, err := resolveSpeakerReplaceFrom(runtime, minuteToken)
-		if err != nil {
-			return err
+		body := map[string]interface{}{
+			"minute_token": minuteToken,
+			"from_user_id": fromUserID,
+			"to_user_id":   toUserID,
 		}
 
-		_, err = runtime.CallAPITyped(http.MethodPut,
+		_, err := runtime.CallAPITyped(http.MethodPut,
 			fmt.Sprintf("/open-apis/minutes/v1/minutes/%s/transcript/speaker", validate.EncodePathSegment(minuteToken)),
-			map[string]interface{}{"user_id_type": "open_id"}, buildSpeakerReplaceRequestBodyResolved(fromSpeakerID, fromUserID, toUserID))
+			nil, body)
 		if err != nil {
-			return minutesSpeakerReplaceError(err, minuteToken, speakerReplaceSourceLabel(fromSpeakerInput, fromSpeakerID, fromUserID))
+			return minutesSpeakerReplaceError(err, minuteToken, fromUserID)
 		}
 
-		runtime.OutFormat(buildSpeakerReplaceOutputData(fromSpeakerInput, minuteToken, fromSpeakerID, fromUserID, toUserID), nil, nil)
+		outData := map[string]interface{}{
+			"minute_token": minuteToken,
+			"from_user_id": fromUserID,
+			"to_user_id":   toUserID,
+		}
+
+		runtime.OutFormat(outData, nil, nil)
 		return nil
 	},
 }
 
-func buildSpeakerReplaceRequestBody(runtime *common.RuntimeContext) map[string]interface{} {
-	fromSpeakerID := strings.TrimSpace(runtime.Str("from-speaker-id"))
-	fromUserID := strings.TrimSpace(runtime.Str("from-user-id"))
-	toUserID := strings.TrimSpace(runtime.Str("to-user-id"))
-	return buildSpeakerReplaceRequestBodyResolved(fromSpeakerID, fromUserID, toUserID)
-}
-
-func buildSpeakerReplaceRequestBodyResolved(fromSpeakerID, fromUserID, toUserID string) map[string]interface{} {
-	body := map[string]interface{}{
-		"to_user_id": toUserID,
-	}
-	if fromSpeakerID != "" {
-		body["from_speaker_id"] = fromSpeakerID
-	} else {
-		body["from_user_id"] = fromUserID
-	}
-	return body
-}
-
-func buildSpeakerReplaceOutputData(fromSpeakerInput, minuteToken, fromSpeakerID, fromUserID, toUserID string) map[string]interface{} {
-	out := map[string]interface{}{
-		"minute_token": minuteToken,
-		"to_user_id":   toUserID,
-	}
-	if fromSpeakerID != "" {
-		out["from_speaker_id"] = fromSpeakerID
-		if fromSpeakerInput != "" && fromSpeakerInput != fromSpeakerID {
-			out["from_speaker_input"] = fromSpeakerInput
-		}
-	} else {
-		out["from_user_id"] = fromUserID
-	}
-	return out
-}
-
-func speakerReplaceSourceLabel(fromSpeakerInput, fromSpeakerID, fromUserID string) string {
-	if fromSpeakerInput != "" {
-		return fromSpeakerInput
-	}
-	if fromSpeakerID != "" {
-		return fromSpeakerID
-	}
-	return fromUserID
-}
-
-func minutesSpeakerReplaceError(err error, minuteToken, sourceSpeaker string) error {
+func minutesSpeakerReplaceError(err error, minuteToken, fromUserID string) error {
 	p, ok := errs.ProblemOf(err)
 	if !ok {
 		return err
@@ -151,8 +112,8 @@ func minutesSpeakerReplaceError(err error, minuteToken, sourceSpeaker string) er
 		p.Hint = "Ask the minute owner for minute edit permission"
 	case minutesSpeakerReplaceSpeakerNotFoundCode:
 		p.Subtype = errs.SubtypeNotFound
-		p.Message = fmt.Sprintf("Speaker not found in minute %q: source speaker %q does not match an existing speaker in the transcript.", minuteToken, sourceSpeaker)
-		p.Hint = "Verify --from-speaker-id is a valid speaker_id or display name from the transcript; if multiple speakers share the same name, pass the exact speaker_id after reviewing their utterances."
+		p.Message = fmt.Sprintf("Speaker not found in minute %q: --from-user-id %q does not match an existing speaker in the transcript.", minuteToken, fromUserID)
+		p.Hint = "Check --minute-token and --from-user-id. Use an open_id for a speaker that appears in the minute transcript, then retry."
 	}
 	return err
 }

shortcuts/minutes/minutes_speaker_replace_test.go

@@ -34,7 +34,7 @@ func TestMinutesSpeakerReplace_Validate(t *testing.T) {
 		{
 			name:    "missing from",
 			args:    []string{"+speaker-replace", "--minute-token", minutesSpeakerReplaceTestToken, "--to-user-id", "ou_b", "--as", "user"},
-			wantErr: "--from-speaker-id is required",
+			wantErr: "required flag(s) \"from-user-id\" not set",
 		},
 		{
 			name:    "missing to",
@@ -153,129 +153,6 @@ func TestMinutesSpeakerReplace_DryRun(t *testing.T) {
 	}
 }
 
-func TestMinutesSpeakerReplace_DryRun_ResolveFromSpeakerID(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, stdout, _, _ := cmdutil.TestFactory(t, defaultConfig())
-	warmTokenCache(t)
-
-	err := mountAndRun(t, MinutesSpeakerReplace, []string{
-		"+speaker-replace",
-		"--minute-token", minutesSpeakerReplaceTestToken,
-		"--from-speaker-id", "说话人1",
-		"--to-user-id", "ou_new_speaker",
-		"--dry-run", "--as", "user",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	out := stdout.String()
-	if !strings.Contains(out, "GET") {
-		t.Errorf("expected GET for internal speaker list, got:\n%s", out)
-	}
-	if !strings.Contains(out, "/transcript/speakerlist") {
-		t.Errorf("expected speakerlist path, got:\n%s", out)
-	}
-	if !strings.Contains(out, "PUT") {
-		t.Errorf("expected PUT for speaker replace, got:\n%s", out)
-	}
-	if !strings.Contains(out, "ou_new_speaker") {
-		t.Errorf("expected to_user_id in body, got:\n%s", out)
-	}
-}
-
-func TestMinutesSpeakerReplace_Execute_ResolveFromSpeakerID(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, stdout, _, reg := cmdutil.TestFactory(t, defaultConfig())
-	warmTokenCache(t)
-
-	reg.Register(&httpmock.Stub{
-		Method: http.MethodGet,
-		URL:    "/open-apis/minutes/v1/minutes/" + minutesSpeakerReplaceTestToken + "/transcript/speakerlist",
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "ok",
-			"data": map[string]interface{}{
-				"speakers": []interface{}{
-					map[string]interface{}{
-						"speaker_id": "ENCRYPTED_TOKEN_ABC",
-						"name":       "说话人1",
-					},
-				},
-			},
-		},
-	})
-	reg.Register(&httpmock.Stub{
-		Method: http.MethodPut,
-		URL:    "/open-apis/minutes/v1/minutes/" + minutesSpeakerReplaceTestToken + "/transcript/speaker",
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "ok",
-			"data": map[string]interface{}{},
-		},
-	})
-
-	err := mountAndRun(t, MinutesSpeakerReplace, []string{
-		"+speaker-replace",
-		"--minute-token", minutesSpeakerReplaceTestToken,
-		"--from-speaker-id", "说话人1",
-		"--to-user-id", "ou_new_speaker",
-		"--format", "json", "--as", "user",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	var envelope struct {
-		Data struct {
-			MinuteToken      string `json:"minute_token"`
-			FromSpeakerInput string `json:"from_speaker_input"`
-			FromSpeakerID    string `json:"from_speaker_id"`
-			ToUserID         string `json:"to_user_id"`
-		} `json:"data"`
-	}
-	if err := json.Unmarshal(stdout.Bytes(), &envelope); err != nil {
-		t.Fatalf("unmarshal stdout: %v", err)
-	}
-	if envelope.Data.FromSpeakerInput != "说话人1" {
-		t.Errorf("data.from_speaker_input = %q, want 说话人1", envelope.Data.FromSpeakerInput)
-	}
-	if envelope.Data.FromSpeakerID != "ENCRYPTED_TOKEN_ABC" {
-		t.Errorf("data.from_speaker_id = %q, want ENCRYPTED_TOKEN_ABC", envelope.Data.FromSpeakerID)
-	}
-}
-
-func TestMinutesSpeakerReplace_DryRun_FromSpeakerID(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, stdout, _, _ := cmdutil.TestFactory(t, defaultConfig())
-	warmTokenCache(t)
-
-	err := mountAndRun(t, MinutesSpeakerReplace, []string{
-		"+speaker-replace",
-		"--minute-token", minutesSpeakerReplaceTestToken,
-		"--from-speaker-id", "ENCRYPTED_TOKEN_ABC",
-		"--to-user-id", "ou_new_speaker",
-		"--dry-run", "--as", "user",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	out := stdout.String()
-	if !strings.Contains(out, "GET") {
-		t.Errorf("expected GET for internal speaker list, got:\n%s", out)
-	}
-	if !strings.Contains(out, "from_speaker_id") || !strings.Contains(out, "ENCRYPTED_TOKEN_ABC") {
-		t.Errorf("expected from_speaker_id in body, got:\n%s", out)
-	}
-	if strings.Contains(out, "from_user_id") {
-		t.Errorf("from_speaker_id path should not send from_user_id, got:\n%s", out)
-	}
-	if !strings.Contains(out, "ou_new_speaker") {
-		t.Errorf("expected to_user_id in body, got:\n%s", out)
-	}
-}
-
 func TestMinutesSpeakerReplace_Execute(t *testing.T) {
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 	f, stdout, _, reg := cmdutil.TestFactory(t, defaultConfig())
@@ -361,8 +238,8 @@ func TestMinutesSpeakerReplace_SpeakerNotFound(t *testing.T) {
 	if !strings.Contains(p.Message, "ou_missing_speaker") {
 		t.Errorf("message should include missing speaker id, got: %s", p.Message)
 	}
-	if !strings.Contains(p.Hint, "--from-speaker-id") {
-		t.Errorf("hint should mention --from-speaker-id, got: %s", p.Hint)
+	if !strings.Contains(p.Hint, "--from-user-id") {
+		t.Errorf("hint should mention --from-user-id, got: %s", p.Hint)
 	}
 }
 

shortcuts/minutes/minutes_speakers.go

@@ -1,104 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package minutes
-
-import (
-	"fmt"
-	"net/http"
-	"strings"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-type minuteSpeaker struct {
-	SpeakerID string
-	Name      string
-}
-
-func minuteTranscriptSpeakerlistPath(minuteToken string) string {
-	return fmt.Sprintf("/open-apis/minutes/v1/minutes/%s/transcript/speakerlist", validate.EncodePathSegment(minuteToken))
-}
-
-func fetchMinuteSpeakers(runtime *common.RuntimeContext, minuteToken string) ([]minuteSpeaker, error) {
-	data, err := runtime.CallAPITyped(http.MethodGet, minuteTranscriptSpeakerlistPath(minuteToken), nil, nil)
-	if err != nil {
-		return nil, err
-	}
-	if data == nil {
-		return nil, nil
-	}
-
-	items := common.GetSlice(data, "speakers")
-	speakers := make([]minuteSpeaker, 0, len(items))
-	for _, raw := range items {
-		item, _ := raw.(map[string]interface{})
-		if item == nil {
-			continue
-		}
-		id := strings.TrimSpace(common.GetString(item, "speaker_id"))
-		name := strings.TrimSpace(common.GetString(item, "name"))
-		if id == "" {
-			continue
-		}
-		speakers = append(speakers, minuteSpeaker{SpeakerID: id, Name: name})
-	}
-	return speakers, nil
-}
-
-func resolveSpeakerIDByName(speakers []minuteSpeaker, name string) (string, error) {
-	name = strings.TrimSpace(name)
-	var matches []minuteSpeaker
-	for _, s := range speakers {
-		if s.Name == name {
-			matches = append(matches, s)
-		}
-	}
-	switch len(matches) {
-	case 0:
-		return "", errs.NewValidationError(errs.SubtypeNotFound,
-			"no speaker named %q in minute transcript", name).
-			WithParam("--from-speaker-id").
-			WithHint("Check the speaker name spelling or open the minute to see transcript speaker labels")
-	case 1:
-		return matches[0].SpeakerID, nil
-	default:
-		ids := make([]string, len(matches))
-		for i, m := range matches {
-			ids[i] = m.SpeakerID
-		}
-		return "", errs.NewValidationError(errs.SubtypeFailedPrecondition,
-			"multiple speakers named %q (%d matches); pass the exact --from-speaker-id", name, len(matches)).
-			WithParam("--from-speaker-id").
-			WithHint(fmt.Sprintf("Matching speaker_ids: %s. Review each speaker's utterances in the minute, then retry with the exact speaker_id", strings.Join(ids, ", ")))
-	}
-}
-
-// resolveFromSpeakerID resolves --from-speaker-id to an API speaker_id.
-// The input may already be an opaque speaker_id, or a display name that requires
-// an internal speaker-list fetch.
-func resolveFromSpeakerID(runtime *common.RuntimeContext, minuteToken, input string) (string, error) {
-	input = strings.TrimSpace(input)
-	speakers, err := fetchMinuteSpeakers(runtime, minuteToken)
-	if err != nil {
-		return "", err
-	}
-	for _, s := range speakers {
-		if s.SpeakerID == input {
-			return input, nil
-		}
-	}
-	return resolveSpeakerIDByName(speakers, input)
-}
-
-func resolveSpeakerReplaceFrom(runtime *common.RuntimeContext, minuteToken string) (fromSpeakerID, fromUserID string, err error) {
-	fromUserID = strings.TrimSpace(runtime.Str("from-user-id"))
-	if fromUserID != "" {
-		return "", fromUserID, nil
-	}
-
-	fromSpeakerID, err = resolveFromSpeakerID(runtime, minuteToken, runtime.Str("from-speaker-id"))
-	return fromSpeakerID, "", err
-}

shortcuts/minutes/minutes_speakers_test.go

@@ -1,45 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package minutes
-
-import (
-	"errors"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-)
-
-func TestResolveSpeakerIDByName(t *testing.T) {
-	speakers := []minuteSpeaker{
-		{SpeakerID: "id_a", Name: "Alice"},
-		{SpeakerID: "id_b", Name: "Bob"},
-		{SpeakerID: "id_c", Name: "Alice"},
-	}
-
-	id, err := resolveSpeakerIDByName(speakers, "Bob")
-	if err != nil || id != "id_b" {
-		t.Fatalf("resolve Bob: id=%q err=%v", id, err)
-	}
-
-	_, err = resolveSpeakerIDByName(speakers, "Carol")
-	if err == nil {
-		t.Fatal("expected not found error")
-	}
-	var ve *errs.ValidationError
-	if !errors.As(err, &ve) || ve.Subtype != errs.SubtypeNotFound {
-		t.Fatalf("want not-found validation error, got %T: %v", err, err)
-	}
-
-	_, err = resolveSpeakerIDByName(speakers, "Alice")
-	if err == nil {
-		t.Fatal("expected duplicate name error")
-	}
-	if !errors.As(err, &ve) || ve.Subtype != errs.SubtypeFailedPrecondition {
-		t.Fatalf("want failed-precondition validation error, got %T: %v", err, err)
-	}
-	if !strings.Contains(ve.Hint, "id_a") || !strings.Contains(ve.Hint, "id_c") {
-		t.Errorf("hint should list matching speaker_ids, got: %s", ve.Hint)
-	}
-}

shortcuts/minutes/minutes_summary.go

@@ -31,7 +31,7 @@ var MinutesSummary = common.Shortcut{
 	},
 	Tips: []string{
 		minutesSummaryMarkdownTip,
-		"Use `lark-cli minutes +detail --minute-tokens <token> --summary` to read the current summary before replacing it.",
+		"Use `lark-cli vc +notes --minute-tokens <token>` to read the current summary before replacing it.",
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
 		minuteToken := runtime.Str("minute-token")

shortcuts/minutes/minutes_todo.go

@@ -59,7 +59,7 @@ var MinutesTodo = common.Shortcut{
 		"Update: `--operation update --todo-id <id> --todo \"...\" --is-done`.",
 		"Delete: `--operation delete --todo-id <id>`.",
 		"`content` is plain text only; markdown formatting is not supported.",
-		"Use `lark-cli minutes +detail --minute-tokens <token> --todo` to read current todos before writing.",
+		"Use `lark-cli vc +notes --minute-tokens <token>` to read current todos before writing.",
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
 		minuteToken := runtime.Str("minute-token")

shortcuts/minutes/minutes_word_replace.go

@@ -148,7 +148,7 @@ func minutesWordReplaceError(err error, minuteToken string) error {
 		if strings.Contains(strings.ToLower(p.Message), "not found in transcript") {
 			p.Subtype = errs.SubtypeNotFound
 			p.Message = fmt.Sprintf("None of the source words were found in minute %q transcript; nothing was replaced.", minuteToken)
-			p.Hint = "Verify each source_word's exact spelling and case against the current transcript (use `minutes +detail --minute-tokens <token> --transcript` to read it), then retry"
+			p.Hint = "Verify each source_word's exact spelling and case against the current transcript (use vc +notes to read it), then retry"
 		}
 	}
 

shortcuts/minutes/shortcuts.go

@@ -16,6 +16,5 @@ func Shortcuts() []common.Shortcut {
 		MinutesTodo,
 		MinutesSpeakerReplace,
 		MinutesWordReplace,
-		MinutesDetail,
 	}
 }

shortcuts/note/note_transcript.go

@@ -153,7 +153,7 @@ func ensureUnifiedNote(ctx context.Context, runtime *common.RuntimeContext, note
 	if detail.DisplayType != "unified" {
 		if detail.VerbatimDocToken != "" {
 			return errs.NewValidationError(errs.SubtypeFailedPrecondition, "note %s is not a unified note (note_display_type=%s, verbatim_doc_token=%s)", noteID, detail.DisplayType, detail.VerbatimDocToken).
-				WithHint("Use docs +fetch --doc %s for normal note transcripts", detail.VerbatimDocToken)
+				WithHint("Use docs +fetch --api-version v2 --doc %s for normal note transcripts", detail.VerbatimDocToken)
 		}
 		return errs.NewValidationError(errs.SubtypeFailedPrecondition, "note %s is not a unified note (note_display_type=%s, verbatim_doc_token=)", noteID, detail.DisplayType).
 			WithHint("Use note +detail to inspect document tokens")

shortcuts/note/note_transcript_test.go

@@ -39,7 +39,7 @@ func TestNoteTranscriptRequiresUnifiedNote(t *testing.T) {
 	if problem.Subtype != errs.SubtypeFailedPrecondition {
 		t.Fatalf("subtype = %v, want FailedPrecondition", problem.Subtype)
 	}
-	if !strings.Contains(problem.Hint, "docs +fetch --doc doc_verbatim") {
+	if !strings.Contains(problem.Hint, "docs +fetch --api-version v2 --doc doc_verbatim") {
 		t.Fatalf("hint = %q, want docs +fetch guidance", problem.Hint)
 	}
 	if stdout.Len() != 0 {

shortcuts/register_test.go

@@ -246,9 +246,8 @@ func TestRegisterShortcutsDocsShortcutHelpIsV2Only(t *testing.T) {
 			shortcutHelp: "Create a Lark document",
 			visibleFlag:  "--content",
 			skillCommand: "lark-cli skills read lark-doc references/lark-doc-create.md",
-			hiddenFlags:  []string{"api-version", "markdown", "folder-token", "wiki-node", "wiki-space"},
+			hiddenFlags:  []string{"title", "markdown", "folder-token", "wiki-node", "wiki-space"},
 			contentHelp: []string{
-				"--title",
 				"AI agents MUST read",
 				"lark-cli skills read lark-doc references/lark-doc-xml.md",
 				"before writing any --content payload",
@@ -258,7 +257,7 @@ func TestRegisterShortcutsDocsShortcutHelpIsV2Only(t *testing.T) {
 				"MUST NOT grep/open local SKILL.md files",
 				"use --help for the latest command flags",
 			},
-			unwanted: []string{"--api-version", "--markdown", "--folder-token", "--wiki-node", "--wiki-space"},
+			unwanted: []string{"--markdown", "--title", "--folder-token", "--wiki-node", "--wiki-space"},
 		},
 		{
 			name:         "fetch",
@@ -266,8 +265,8 @@ func TestRegisterShortcutsDocsShortcutHelpIsV2Only(t *testing.T) {
 			shortcutHelp: "Fetch Lark document content",
 			visibleFlag:  "read scope",
 			skillCommand: "lark-cli skills read lark-doc references/lark-doc-fetch.md",
-			hiddenFlags:  []string{"api-version", "offset", "limit"},
-			unwanted:     []string{"--api-version", "--offset", "--limit"},
+			hiddenFlags:  []string{"offset", "limit"},
+			unwanted:     []string{"--offset", "--limit"},
 		},
 		{
 			name:         "update",
@@ -275,7 +274,7 @@ func TestRegisterShortcutsDocsShortcutHelpIsV2Only(t *testing.T) {
 			shortcutHelp: "Update a Lark document",
 			visibleFlag:  "--command",
 			skillCommand: "lark-cli skills read lark-doc references/lark-doc-update.md",
-			hiddenFlags:  []string{"api-version", "mode", "markdown", "selection-with-ellipsis", "selection-by-title", "new-title"},
+			hiddenFlags:  []string{"mode", "markdown", "selection-with-ellipsis", "selection-by-title", "new-title"},
 			contentHelp: []string{
 				"AI agents MUST read",
 				"lark-cli skills read lark-doc references/lark-doc-xml.md",
@@ -286,7 +285,7 @@ func TestRegisterShortcutsDocsShortcutHelpIsV2Only(t *testing.T) {
 				"MUST NOT grep/open local SKILL.md files",
 				"use --help for the latest command flags",
 			},
-			unwanted: []string{"--api-version", "--mode", "--markdown", "--selection-with-ellipsis", "--selection-by-title", "--new-title"},
+			unwanted: []string{"--mode", "--markdown", "--selection-with-ellipsis", "--selection-by-title", "--new-title"},
 		},
 	}
 
@@ -312,6 +311,17 @@ func TestRegisterShortcutsDocsShortcutHelpIsV2Only(t *testing.T) {
 					t.Fatalf("docs %s flag %q should be hidden", tt.shortcut, flagName)
 				}
 			}
+			apiVersionFlag := cmd.Flags().Lookup("api-version")
+			if apiVersionFlag == nil {
+				t.Fatalf("docs %s missing --api-version flag", tt.shortcut)
+			}
+			if apiVersionFlag.Hidden {
+				t.Fatalf("docs %s --api-version should be visible", tt.shortcut)
+			}
+			if apiVersionFlag.DefValue != "v2" {
+				t.Fatalf("docs %s --api-version default = %q, want v2", tt.shortcut, apiVersionFlag.DefValue)
+			}
+
 			var out bytes.Buffer
 			cmd.SetOut(&out)
 			if err := cmd.Help(); err != nil {
@@ -321,6 +331,10 @@ func TestRegisterShortcutsDocsShortcutHelpIsV2Only(t *testing.T) {
 			for _, want := range []string{
 				tt.shortcutHelp,
 				tt.visibleFlag,
+				"--api-version",
+				"deprecated compatibility flag; docs shortcuts always use v2",
+				"both v1/v2 are accepted",
+				"(default \"v2\")",
 				"Start here (required for AI agents):",
 				"AI agents MUST read the matching embedded skill",
 				"Do not skip this step",

shortcuts/sheets/backward/lark_sheets_float_images.go

@@ -7,7 +7,6 @@ import (
 	"context"
 	"fmt"
 	"path/filepath"
-	"strings"
 
 	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/extension/fileio"
@@ -15,25 +14,7 @@ import (
 	"github.com/larksuite/cli/shortcuts/common"
 )
 
-// Drive media parent_type values for uploading an image into a spreadsheet.
-// Native spreadsheets use "sheet_image"; imported "office" spreadsheets carry a
-// synthetic token prefixed with "fake_office_" and the backend requires
-// "office_sheet_file" instead.
-const (
-	sheetImageParentType      = "sheet_image"
-	officeSheetFileParentType = "office_sheet_file"
-	fakeOfficeTokenPrefix     = "fake_office_"
-)
-
-// sheetMediaParentType returns the drive media parent_type to use when
-// uploading an image whose parent_node is spreadsheetToken, mapping the
-// "fake_office_" imported-spreadsheet token prefix to "office_sheet_file".
-func sheetMediaParentType(spreadsheetToken string) string {
-	if strings.HasPrefix(spreadsheetToken, fakeOfficeTokenPrefix) {
-		return officeSheetFileParentType
-	}
-	return sheetImageParentType
-}
+const sheetImageParentType = "sheet_image"
 
 var SheetMediaUpload = common.Shortcut{
 	Service:     "sheets",
@@ -68,7 +49,7 @@ var SheetMediaUpload = common.Shortcut{
 				POST("/open-apis/drive/v1/medias/upload_prepare").
 				Body(map[string]interface{}{
 					"file_name":   fileName,
-					"parent_type": sheetMediaParentType(parentNode),
+					"parent_type": sheetImageParentType,
 					"parent_node": parentNode,
 					"size":        "<file_size>",
 				}).
@@ -90,7 +71,7 @@ var SheetMediaUpload = common.Shortcut{
 			POST("/open-apis/drive/v1/medias/upload_all").
 			Body(map[string]interface{}{
 				"file_name":   fileName,
-				"parent_type": sheetMediaParentType(parentNode),
+				"parent_type": sheetImageParentType,
 				"parent_node": parentNode,
 				"size":        "<file_size>",
 				"file":        "@" + filePath,
@@ -160,14 +141,13 @@ func resolveSheetMediaUploadParent(runtime *common.RuntimeContext) (string, erro
 }
 
 func uploadSheetMediaFile(runtime *common.RuntimeContext, filePath, fileName string, fileSize int64, parentNode string) (string, error) {
-	parentType := sheetMediaParentType(parentNode)
 	if fileSize <= common.MaxDriveMediaUploadSinglePartSize {
 		pn := parentNode
 		return common.UploadDriveMediaAllTyped(runtime, common.DriveMediaUploadAllConfig{
 			FilePath:   filePath,
 			FileName:   fileName,
 			FileSize:   fileSize,
-			ParentType: parentType,
+			ParentType: sheetImageParentType,
 			ParentNode: &pn,
 		})
 	}
@@ -175,7 +155,7 @@ func uploadSheetMediaFile(runtime *common.RuntimeContext, filePath, fileName str
 		FilePath:   filePath,
 		FileName:   fileName,
 		FileSize:   fileSize,
-		ParentType: parentType,
+		ParentType: sheetImageParentType,
 		ParentNode: parentNode,
 	})
 }

shortcuts/sheets/backward/lark_sheets_sheet_media_upload_test.go

@@ -91,39 +91,6 @@ func TestSheetMediaUploadDryRunSmallFile(t *testing.T) {
 	}
 }
 
-// TestSheetMediaUploadDryRunSmallFileOfficeParentType pins the small-file
-// upload_all dry-run preview to the token-derived parent_type so the preview
-// agents/users will copy matches what Execute actually sends. Without this the
-// multipart dry-run branch could drift back to a hard-coded "sheet_image".
-func TestSheetMediaUploadDryRunSmallFileOfficeParentType(t *testing.T) {
-	dir := t.TempDir()
-	withSheetsTestWorkingDir(t, dir)
-	if err := os.WriteFile("img.png", []byte("png-bytes"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-
-	f, stdout, _, _ := cmdutil.TestFactory(t, sheetsTestConfig())
-	err := mountAndRunSheets(t, SheetMediaUpload, []string{
-		"+media-upload",
-		"--spreadsheet-token", "fake_office_abc123",
-		"--file", "img.png",
-		"--dry-run", "--as", "user",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	out := stdout.String()
-	if !strings.Contains(out, "/open-apis/drive/v1/medias/upload_all") {
-		t.Fatalf("dry-run should use upload_all for small file, got: %s", out)
-	}
-	if !strings.Contains(out, `"office_sheet_file"`) {
-		t.Fatalf("dry-run should include parent_type=office_sheet_file for fake_office_ token, got: %s", out)
-	}
-	if strings.Contains(out, `"sheet_image"`) {
-		t.Fatalf("dry-run must not emit sheet_image for fake_office_ token, got: %s", out)
-	}
-}
-
 func TestSheetMediaUploadDryRunURLExtractsToken(t *testing.T) {
 	dir := t.TempDir()
 	withSheetsTestWorkingDir(t, dir)
@@ -238,47 +205,6 @@ func TestSheetMediaUploadExecuteSuccess(t *testing.T) {
 	}
 }
 
-// TestSheetMediaUploadExecuteOfficeParentType confirms that an imported
-// "office" spreadsheet (token prefixed with "fake_office_") uploads with
-// parent_type=office_sheet_file instead of the native sheet_image.
-func TestSheetMediaUploadExecuteOfficeParentType(t *testing.T) {
-	dir := t.TempDir()
-	withSheetsTestWorkingDir(t, dir)
-	if err := os.WriteFile("img.png", []byte("png-bytes"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-
-	f, stdout, _, reg := cmdutil.TestFactory(t, sheetsTestConfig())
-	stub := &httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/drive/v1/medias/upload_all",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{"file_token": "boxTOK123"},
-		},
-	}
-	reg.Register(stub)
-
-	const officeToken = "fake_office_abc123"
-	err := mountAndRunSheets(t, SheetMediaUpload, []string{
-		"+media-upload",
-		"--spreadsheet-token", officeToken,
-		"--file", "img.png",
-		"--as", "user",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	body := decodeSheetsMultipartBody(t, stub)
-	if got := body.Fields["parent_type"]; got != officeSheetFileParentType {
-		t.Fatalf("parent_type = %q, want %q", got, officeSheetFileParentType)
-	}
-	if got := body.Fields["parent_node"]; got != officeToken {
-		t.Fatalf("parent_node = %q, want %q", got, officeToken)
-	}
-}
-
 func TestSheetMediaUploadFileNotFound(t *testing.T) {
 	dir := t.TempDir()
 	withSheetsTestWorkingDir(t, dir)

shortcuts/sheets/batch_op_dispatch.go

@@ -332,21 +332,11 @@ func translateBatchOp(raw interface{}, token string, index int) (map[string]inte
 	}, nil
 }
 
-// maxBatchOperations caps how many sub-operations a single +batch-update may
-// carry. Every translated op (with its own cells/properties payload) is held in
-// the out slice at once before the whole batch is marshaled, so an unbounded
-// operation count is the same unbounded-materialization hazard as the fan-out
-// matrix, on the operations axis.
-const maxBatchOperations = 100
-
 // translateBatchOperations 翻译整个 ops 数组；fail-fast，遇错立即返回。
 func translateBatchOperations(rawOps []interface{}, token string) ([]interface{}, error) {
 	if len(rawOps) == 0 {
 		return nil, sheetsValidationForFlag("operations", "--operations must be a non-empty JSON array")
 	}
-	if len(rawOps) > maxBatchOperations {
-		return nil, sheetsValidationForFlag("operations", "--operations accepts at most %d entries; got %d", maxBatchOperations, len(rawOps))
-	}
 	out := make([]interface{}, 0, len(rawOps))
 	for i, raw := range rawOps {
 		translated, err := translateBatchOp(raw, token, i)

shortcuts/sheets/data/flag-defs.json

@@ -1,59 +1,4 @@
 {
-  "+formula-verify": {
-    "risk": "read",
-    "flags": [
-      {
-        "name": "url",
-        "kind": "public",
-        "type": "string",
-        "required": "xor",
-        "desc": "Spreadsheet URL (XOR with `--spreadsheet-token`)"
-      },
-      {
-        "name": "spreadsheet-token",
-        "kind": "public",
-        "type": "string",
-        "required": "xor",
-        "desc": "Spreadsheet token (XOR with `--url`)"
-      },
-      {
-        "name": "sheet-id",
-        "kind": "public",
-        "type": "string_slice",
-        "required": "optional",
-        "desc": "Sheet reference_id(s); repeat or comma-separate to scan multiple sheets. Omit to scan all visible sheets."
-      },
-      {
-        "name": "sheet-name",
-        "kind": "public",
-        "type": "string_slice",
-        "required": "optional",
-        "desc": "Sheet name(s); repeat or comma-separate to scan multiple sheets. Omit to scan all visible sheets."
-      },
-      {
-        "name": "range",
-        "kind": "own",
-        "type": "string_slice",
-        "required": "optional",
-        "desc": "Optional A1 ranges (e.g. `A1:Z200`); repeat or comma-separate for multiple ranges. Omit to scan each sheet's current_region."
-      },
-      {
-        "name": "max-locations",
-        "kind": "own",
-        "type": "int",
-        "required": "optional",
-        "desc": "Max locations / samples per error type; default 20.",
-        "default": "20"
-      },
-      {
-        "name": "exit-on-error",
-        "kind": "own",
-        "type": "bool",
-        "required": "optional",
-        "desc": "When status=errors_found, exit non-zero. Useful for CI gate after batch formula writes."
-      }
-    ]
-  },
   "+workbook-info": {
     "risk": "read",
     "flags": [
@@ -128,14 +73,6 @@
         "desc": "Initial column count (default 20, max 200)",
         "default": "20"
       },
-      {
-        "name": "type",
-        "kind": "own",
-        "type": "string",
-        "required": "optional",
-        "desc": "New sub-sheet type: sheet (spreadsheet) | bitable; default sheet. bitable creates an empty table only — edit its content via lark-base commands",
-        "default": "sheet"
-      },
       {
         "name": "dry-run",
         "kind": "system",
@@ -282,7 +219,7 @@
         "kind": "own",
         "type": "int",
         "required": "optional",
-        "desc": "Source position (0-based); optional for standalone calls — if omitted, the CLI runtime derives it from the current workbook index of `--sheet-id` / `--sheet-name`. Inside `+batch-update` it must be passed explicitly, since batch cannot issue a structure query mid-run to derive it",
+        "desc": "Source position (0-based); optional. If omitted, the CLI runtime derives it from the current workbook index of `--sheet-id` / `--sheet-name`",
         "default": "-1"
       },
       {
@@ -578,7 +515,7 @@
         "kind": "own",
         "type": "string",
         "required": "optional",
-        "desc": "Untyped initial data as one 2D JSON array (`[[\"alice\",95]]`); values are written as-is with their type auto-detected (dates / numbers land as text — use --sheets to preserve types), through the same batched set_cell_range path as --sheets — pair with --styles for number formats, colors, merges, and row/col sizes",
+        "desc": "Untyped initial data as one 2D JSON array (`[[\"alice\",95]]`); values are written as-is with their type auto-detected, through the same batched set_cell_range path as --sheets — pair with --styles for number formats, colors, merges, and row/col sizes",
         "input": [
           "file",
           "stdin"
@@ -1132,7 +1069,7 @@
         "kind": "own",
         "type": "int",
         "required": "optional",
-        "desc": "Group nesting level to ungroup; default 1 (1 = outermost, larger = deeper)",
+        "desc": "Group nesting level to ungroup; default 1 (outermost)",
         "default": "1"
       },
       {
@@ -1774,13 +1711,6 @@
         "required": "optional",
         "desc": "Font color (hex, e.g. `#000000`)"
       },
-      {
-        "name": "font-family",
-        "kind": "own",
-        "type": "string",
-        "required": "optional",
-        "desc": "Font family name (e.g. `Arial`, `Microsoft YaHei`)"
-      },
       {
         "name": "font-size",
         "kind": "own",
@@ -2809,7 +2739,7 @@
         "kind": "own",
         "type": "string",
         "required": "required",
-        "desc": "Target ranges as a JSON array (e.g. `[\"Sheet1!A1:B2\",\"Sheet2!D1:D10\"]`, prefix written bare without quotes); each prefix must exactly match the sheet display name (case-sensitive), not the sheet reference_id; ranges may target different sheets; the same style is applied to every range",
+        "desc": "Target ranges as a JSON array (e.g. `[\"'Sheet1'!A1:B2\",\"'Sheet2'!D1:D10\"]`); each item must include a sheet prefix; the prefix must be the sheet display name (e.g. `Sheet1`), not the sheet reference_id; ranges may target different sheets; the same style is applied to every range",
         "input": [
           "file",
           "stdin"
@@ -2829,13 +2759,6 @@
         "required": "optional",
         "desc": "Font color (hex, e.g. `#000000`)"
       },
-      {
-        "name": "font-family",
-        "kind": "own",
-        "type": "string",
-        "required": "optional",
-        "desc": "Font family name (e.g. `Arial`, `Microsoft YaHei`)"
-      },
       {
         "name": "font-size",
         "kind": "own",
@@ -2962,7 +2885,7 @@
         "kind": "own",
         "type": "string",
         "required": "required",
-        "desc": "Target ranges as a JSON array (e.g. `[\"Sheet1!A2:A100\",\"Sheet1!C2:C100\"]`, prefix written bare without quotes); each item must include a sheet prefix; the prefix must exactly match the sheet display name (case-sensitive), not the sheet reference_id",
+        "desc": "Target ranges as a JSON array (e.g. `[\"'Sheet1'!A2:A100\",\"'Sheet1'!C2:C100\"]`); each item must include a sheet prefix; the prefix must be the sheet display name (e.g. `Sheet1`), not the sheet reference_id",
         "input": [
           "file",
           "stdin"
@@ -3042,7 +2965,7 @@
         "kind": "own",
         "type": "string",
         "required": "required",
-        "desc": "Target ranges as a JSON array (up to 100 items, e.g. `[\"Sheet1!E2:E6\"]`, prefix written bare without quotes); each item must include a sheet prefix; the prefix must exactly match the sheet display name (case-sensitive), not the sheet reference_id",
+        "desc": "Target ranges as a JSON array (up to 100 items, e.g. `[\"'Sheet1'!E2:E6\"]`); each item must include a sheet prefix; the prefix must be the sheet display name (e.g. `Sheet1`), not the sheet reference_id",
         "input": [
           "file",
           "stdin"
@@ -3086,7 +3009,7 @@
         "kind": "own",
         "type": "string",
         "required": "required",
-        "desc": "Target ranges as a JSON array (e.g. `[\"Sheet1!A2:Z1000\",\"Sheet2!A2:Z1000\"]`, prefix written bare without quotes); each prefix must exactly match the sheet display name (case-sensitive), not the sheet reference_id; ranges may target different sheets; the same scope is cleared from every range",
+        "desc": "Target ranges as a JSON array (e.g. `[\"'Sheet1'!A2:Z1000\",\"'Sheet2'!A2:Z1000\"]`); each item must include a sheet prefix; the prefix must be the sheet display name (e.g. `Sheet1`), not the sheet reference_id; ranges may target different sheets; the same scope is cleared from every range",
         "input": [
           "file",
           "stdin"
@@ -3204,7 +3127,7 @@
         "kind": "own",
         "type": "string",
         "required": "required",
-        "desc": "Full chart config JSON. Top-level keys: `position` / `offset` / `size` / `snapshot` (no top-level `data`, no extra nested `properties`); chart data config lives under `snapshot.data` (`refs` / `headerMode` / `dim1` / `dim2`); must include at least one of `snapshot.data.dim1.serie.index` or `dim2.series[].index`, otherwise the server rejects it. Deeply nested — run `--print-schema --flag-name properties` for the full structure.",
+        "desc": "Full chart config JSON. Top-level keys: `position` / `offset` / `size` / `snapshot` (no top-level `data`, no extra nested `properties`); chart data config lives under `snapshot.data` (`refs` / `headerMode` / `dim1` / `dim2`). Deeply nested — run `--print-schema --flag-name properties` for the full structure.",
         "input": [
           "file",
           "stdin"
@@ -4143,7 +4066,7 @@
         "kind": "own",
         "type": "string",
         "required": "optional",
-        "desc": "Filter-view name; auto-assigned by the server when omitted; takes precedence over the same-named field inside `--properties`"
+        "desc": "Filter-view name; auto-assigned by the server when omitted on create, kept unchanged when omitted on update; takes precedence over the same-named field inside `--properties`"
       },
       {
         "name": "dry-run",
@@ -4824,104 +4747,5 @@
         "desc": ""
       }
     ]
-  },
-  "+history-list": {
-    "risk": "read",
-    "flags": [
-      {
-        "name": "url",
-        "kind": "public",
-        "type": "string",
-        "required": "xor",
-        "desc": "Spreadsheet locator"
-      },
-      {
-        "name": "spreadsheet-token",
-        "kind": "public",
-        "type": "string",
-        "required": "xor",
-        "desc": "Spreadsheet locator"
-      },
-      {
-        "name": "end-version",
-        "kind": "own",
-        "type": "int",
-        "required": "optional",
-        "desc": "Max version to query (descending pagination). Omit on the first call; pass next_end_version from the previous response."
-      },
-      {
-        "name": "dry-run",
-        "kind": "system",
-        "type": "bool",
-        "required": "optional",
-        "desc": ""
-      }
-    ]
-  },
-  "+history-revert": {
-    "risk": "write",
-    "flags": [
-      {
-        "name": "url",
-        "kind": "public",
-        "type": "string",
-        "required": "xor",
-        "desc": "Spreadsheet locator"
-      },
-      {
-        "name": "spreadsheet-token",
-        "kind": "public",
-        "type": "string",
-        "required": "xor",
-        "desc": "Spreadsheet locator"
-      },
-      {
-        "name": "history-version-id",
-        "kind": "own",
-        "type": "string",
-        "required": "required",
-        "desc": "History version to revert to (from +history-list)."
-      },
-      {
-        "name": "dry-run",
-        "kind": "system",
-        "type": "bool",
-        "required": "optional",
-        "desc": ""
-      }
-    ]
-  },
-  "+history-revert-status": {
-    "risk": "read",
-    "flags": [
-      {
-        "name": "url",
-        "kind": "public",
-        "type": "string",
-        "required": "xor",
-        "desc": "Spreadsheet locator"
-      },
-      {
-        "name": "spreadsheet-token",
-        "kind": "public",
-        "type": "string",
-        "required": "xor",
-        "desc": "Spreadsheet locator"
-      },
-      {
-        "name": "transaction-id",
-        "kind": "own",
-        "type": "string",
-        "required": "required",
-        "desc": "Async revert transaction id (from +history-revert)."
-      },
-      {
-        "name": "dry-run",
-        "kind": "system",
-        "type": "bool",
-        "required": "optional",
-        "desc": ""
-      }
-    ]
   }
 }

shortcuts/sheets/flag_defs_gen.go

@@ -27,7 +27,7 @@ var flagDefs = map[string]commandDef{
 		Flags: []flagDef{
 			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet URL (XOR with `--spreadsheet-token`)"},
 			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
-			{Name: "ranges", Kind: "own", Type: "string", Required: "required", Desc: "Target ranges as a JSON array (e.g. `[\"Sheet1!A2:Z1000\",\"Sheet2!A2:Z1000\"]`, prefix written bare without quotes); each prefix must exactly match the sheet display name (case-sensitive), not the sheet reference_id; ranges may target different sheets; the same scope is cleared from every range", Input: []string{"file", "stdin"}},
+			{Name: "ranges", Kind: "own", Type: "string", Required: "required", Desc: "Target ranges as a JSON array (e.g. `[\"'Sheet1'!A2:Z1000\",\"'Sheet2'!A2:Z1000\"]`); each item must include a sheet prefix; the prefix must be the sheet display name (e.g. `Sheet1`), not the sheet reference_id; ranges may target different sheets; the same scope is cleared from every range", Input: []string{"file", "stdin"}},
 			{Name: "scope", Kind: "own", Type: "string", Required: "optional", Desc: "Clear scope: `content` (default, values only) / `formats` (formats only) / `all` (values and formats)", Default: "content", Enum: []string{"content", "formats", "all"}},
 			{Name: "yes", Kind: "system", Type: "bool", Required: "required", Desc: "Confirm destructive write (exit code 10 without this flag); batch clear is irreversible"},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
@@ -38,10 +38,9 @@ var flagDefs = map[string]commandDef{
 		Flags: []flagDef{
 			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet URL (XOR with `--spreadsheet-token`)"},
 			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
-			{Name: "ranges", Kind: "own", Type: "string", Required: "required", Desc: "Target ranges as a JSON array (e.g. `[\"Sheet1!A1:B2\",\"Sheet2!D1:D10\"]`, prefix written bare without quotes); each prefix must exactly match the sheet display name (case-sensitive), not the sheet reference_id; ranges may target different sheets; the same style is applied to every range", Input: []string{"file", "stdin"}},
+			{Name: "ranges", Kind: "own", Type: "string", Required: "required", Desc: "Target ranges as a JSON array (e.g. `[\"'Sheet1'!A1:B2\",\"'Sheet2'!D1:D10\"]`); each item must include a sheet prefix; the prefix must be the sheet display name (e.g. `Sheet1`), not the sheet reference_id; ranges may target different sheets; the same style is applied to every range", Input: []string{"file", "stdin"}},
 			{Name: "background-color", Kind: "own", Type: "string", Required: "optional", Desc: "Background color (hex, e.g. `#ffffff`)"},
 			{Name: "font-color", Kind: "own", Type: "string", Required: "optional", Desc: "Font color (hex, e.g. `#000000`)"},
-			{Name: "font-family", Kind: "own", Type: "string", Required: "optional", Desc: "Font family name (e.g. `Arial`, `Microsoft YaHei`)"},
 			{Name: "font-size", Kind: "own", Type: "float64", Required: "optional", Desc: "Font size in px (e.g. 10, 12, 14)"},
 			{Name: "font-style", Kind: "own", Type: "string", Required: "optional", Desc: "Font style", Enum: []string{"normal", "italic"}},
 			{Name: "font-weight", Kind: "own", Type: "string", Required: "optional", Desc: "Font weight", Enum: []string{"normal", "bold"}},
@@ -166,7 +165,6 @@ var flagDefs = map[string]commandDef{
 			{Name: "range", Kind: "own", Type: "string", Required: "required", Desc: "Target range (A1 notation, e.g. `A1:B2`)"},
 			{Name: "background-color", Kind: "own", Type: "string", Required: "optional", Desc: "Background color (hex, e.g. `#ffffff`)"},
 			{Name: "font-color", Kind: "own", Type: "string", Required: "optional", Desc: "Font color (hex, e.g. `#000000`)"},
-			{Name: "font-family", Kind: "own", Type: "string", Required: "optional", Desc: "Font family name (e.g. `Arial`, `Microsoft YaHei`)"},
 			{Name: "font-size", Kind: "own", Type: "float64", Required: "optional", Desc: "Font size in px (e.g. 10, 12, 14)"},
 			{Name: "font-style", Kind: "own", Type: "string", Required: "optional", Desc: "Font style", Enum: []string{"normal", "italic"}},
 			{Name: "font-weight", Kind: "own", Type: "string", Required: "optional", Desc: "Font weight", Enum: []string{"normal", "bold"}},
@@ -197,7 +195,7 @@ var flagDefs = map[string]commandDef{
 			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
 			{Name: "sheet-id", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet reference_id (XOR with `--sheet-name`)"},
 			{Name: "sheet-name", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet name (XOR with `--sheet-id`)"},
-			{Name: "properties", Kind: "own", Type: "string", Required: "required", Desc: "Full chart config JSON. Top-level keys: `position` / `offset` / `size` / `snapshot` (no top-level `data`, no extra nested `properties`); chart data config lives under `snapshot.data` (`refs` / `headerMode` / `dim1` / `dim2`); must include at least one of `snapshot.data.dim1.serie.index` or `dim2.series[].index`, otherwise the server rejects it. Deeply nested — run `--print-schema --flag-name properties` for the full structure.", Input: []string{"file", "stdin"}},
+			{Name: "properties", Kind: "own", Type: "string", Required: "required", Desc: "Full chart config JSON. Top-level keys: `position` / `offset` / `size` / `snapshot` (no top-level `data`, no extra nested `properties`); chart data config lives under `snapshot.data` (`refs` / `headerMode` / `dim1` / `dim2`). Deeply nested — run `--print-schema --flag-name properties` for the full structure.", Input: []string{"file", "stdin"}},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional", Desc: "Print the request template; no side effects"},
 		},
 	},
@@ -407,7 +405,7 @@ var flagDefs = map[string]commandDef{
 			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
 			{Name: "sheet-id", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet reference_id (XOR with `--sheet-name`)"},
 			{Name: "sheet-name", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet name (XOR with `--sheet-id`)"},
-			{Name: "depth", Kind: "own", Type: "int", Required: "optional", Desc: "Group nesting level to ungroup; default 1 (1 = outermost, larger = deeper)", Default: "1"},
+			{Name: "depth", Kind: "own", Type: "int", Required: "optional", Desc: "Group nesting level to ungroup; default 1 (outermost)", Default: "1"},
 			{Name: "range", Kind: "own", Type: "string", Required: "required", Desc: "Row/column closed range to ungroup; rows use 1-based numbers like `3:7`, columns use letters like `C:F`"},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
@@ -428,7 +426,7 @@ var flagDefs = map[string]commandDef{
 		Flags: []flagDef{
 			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet URL (XOR with `--spreadsheet-token`)"},
 			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
-			{Name: "ranges", Kind: "own", Type: "string", Required: "required", Desc: "Target ranges as a JSON array (up to 100 items, e.g. `[\"Sheet1!E2:E6\"]`, prefix written bare without quotes); each item must include a sheet prefix; the prefix must exactly match the sheet display name (case-sensitive), not the sheet reference_id", Input: []string{"file", "stdin"}},
+			{Name: "ranges", Kind: "own", Type: "string", Required: "required", Desc: "Target ranges as a JSON array (up to 100 items, e.g. `[\"'Sheet1'!E2:E6\"]`); each item must include a sheet prefix; the prefix must be the sheet display name (e.g. `Sheet1`), not the sheet reference_id", Input: []string{"file", "stdin"}},
 			{Name: "yes", Kind: "system", Type: "bool", Required: "required", Desc: "Confirm high-risk write (exit code 10 without this flag)"},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
@@ -465,7 +463,7 @@ var flagDefs = map[string]commandDef{
 		Flags: []flagDef{
 			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet URL (XOR with `--spreadsheet-token`)"},
 			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
-			{Name: "ranges", Kind: "own", Type: "string", Required: "required", Desc: "Target ranges as a JSON array (e.g. `[\"Sheet1!A2:A100\",\"Sheet1!C2:C100\"]`, prefix written bare without quotes); each item must include a sheet prefix; the prefix must exactly match the sheet display name (case-sensitive), not the sheet reference_id", Input: []string{"file", "stdin"}},
+			{Name: "ranges", Kind: "own", Type: "string", Required: "required", Desc: "Target ranges as a JSON array (e.g. `[\"'Sheet1'!A2:A100\",\"'Sheet1'!C2:C100\"]`); each item must include a sheet prefix; the prefix must be the sheet display name (e.g. `Sheet1`), not the sheet reference_id", Input: []string{"file", "stdin"}},
 			{Name: "options", Kind: "own", Type: "string", Required: "xor", Desc: "Options as a JSON array, e.g. `[\"opt1\",\"opt2\"]`. Server enforces no item-count cap and no per-item length cap; values containing commas are accepted (they are escape-encoded on the wire). For very large lists prefer `--source-range`.", Input: []string{"file", "stdin"}},
 			{Name: "colors", Kind: "own", Type: "string", Required: "optional", Desc: "Per-option pill colors, RGB hex array (e.g. `[\"#1FB6C1\",\"#F006C2\"]`). Length may be shorter than the source (`--options` items / `--source-range` cells) — extras cycle through a 10-color palette — but never longer (CLI Validate rejects: `--colors length (N) must not exceed dropdown source size (M)`). **Applies on its own**; ignored when `--highlight=false`.", Input: []string{"file", "stdin"}},
 			{Name: "multiple", Kind: "own", Type: "bool", Required: "optional", Desc: "Enable multi-select"},
@@ -528,7 +526,7 @@ var flagDefs = map[string]commandDef{
 			{Name: "sheet-name", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet name (XOR with `--sheet-id`)"},
 			{Name: "properties", Kind: "own", Type: "string", Required: "required", Desc: "Filter-view rule JSON: `rules?` (per-column rule array), `filtered_columns?`. `range` and `view_name` are separate flags", Input: []string{"file", "stdin"}},
 			{Name: "range", Kind: "own", Type: "string", Required: "required", Desc: "Range the filter view applies to (A1 notation, e.g. `A1:F1000`); takes precedence over the same-named field inside `--properties`; required on create and must cover the header row"},
-			{Name: "view-name", Kind: "own", Type: "string", Required: "optional", Desc: "Filter-view name; auto-assigned by the server when omitted; takes precedence over the same-named field inside `--properties`"},
+			{Name: "view-name", Kind: "own", Type: "string", Required: "optional", Desc: "Filter-view name; auto-assigned by the server when omitted on create, kept unchanged when omitted on update; takes precedence over the same-named field inside `--properties`"},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
 	},
@@ -634,45 +632,6 @@ var flagDefs = map[string]commandDef{
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
 	},
-	"+formula-verify": {
-		Risk: "read",
-		Flags: []flagDef{
-			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet URL (XOR with `--spreadsheet-token`)"},
-			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
-			{Name: "sheet-id", Kind: "public", Type: "string_slice", Required: "optional", Desc: "Sheet reference_id(s); repeat or comma-separate to scan multiple sheets. Omit to scan all visible sheets."},
-			{Name: "sheet-name", Kind: "public", Type: "string_slice", Required: "optional", Desc: "Sheet name(s); repeat or comma-separate to scan multiple sheets. Omit to scan all visible sheets."},
-			{Name: "range", Kind: "own", Type: "string_slice", Required: "optional", Desc: "Optional A1 ranges (e.g. `A1:Z200`); repeat or comma-separate for multiple ranges. Omit to scan each sheet's current_region."},
-			{Name: "max-locations", Kind: "own", Type: "int", Required: "optional", Desc: "Max locations / samples per error type; default 20.", Default: "20"},
-			{Name: "exit-on-error", Kind: "own", Type: "bool", Required: "optional", Desc: "When status=errors_found, exit non-zero. Useful for CI gate after batch formula writes."},
-		},
-	},
-	"+history-list": {
-		Risk: "read",
-		Flags: []flagDef{
-			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet locator"},
-			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet locator"},
-			{Name: "end-version", Kind: "own", Type: "int", Required: "optional", Desc: "Max version to query (descending pagination). Omit on the first call; pass next_end_version from the previous response."},
-			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
-		},
-	},
-	"+history-revert": {
-		Risk: "write",
-		Flags: []flagDef{
-			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet locator"},
-			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet locator"},
-			{Name: "history-version-id", Kind: "own", Type: "string", Required: "required", Desc: "History version to revert to (from +history-list)."},
-			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
-		},
-	},
-	"+history-revert-status": {
-		Risk: "read",
-		Flags: []flagDef{
-			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet locator"},
-			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet locator"},
-			{Name: "transaction-id", Kind: "own", Type: "string", Required: "required", Desc: "Async revert transaction id (from +history-revert)."},
-			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
-		},
-	},
 	"+pivot-create": {
 		Risk: "write",
 		Flags: []flagDef{
@@ -809,7 +768,6 @@ var flagDefs = map[string]commandDef{
 			{Name: "index", Kind: "own", Type: "int", Required: "optional", Desc: "Insert position (0-based); appended to the end when omitted", Default: "-1"},
 			{Name: "row-count", Kind: "own", Type: "int", Required: "optional", Desc: "Initial row count (default 200, max 50000)", Default: "200"},
 			{Name: "col-count", Kind: "own", Type: "int", Required: "optional", Desc: "Initial column count (default 20, max 200)", Default: "20"},
-			{Name: "type", Kind: "own", Type: "string", Required: "optional", Desc: "New sub-sheet type: sheet (spreadsheet) | bitable; default sheet. bitable creates an empty table only — edit its content via lark-base commands", Default: "sheet"},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
 	},
@@ -864,7 +822,7 @@ var flagDefs = map[string]commandDef{
 			{Name: "sheet-id", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet reference_id (XOR with `--sheet-name`)"},
 			{Name: "sheet-name", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet name (XOR with `--sheet-id`)"},
 			{Name: "index", Kind: "own", Type: "int", Required: "required", Desc: "Target position (0-based)"},
-			{Name: "source-index", Kind: "own", Type: "int", Required: "optional", Desc: "Source position (0-based); optional for standalone calls — if omitted, the CLI runtime derives it from the current workbook index of `--sheet-id` / `--sheet-name`. Inside `+batch-update` it must be passed explicitly, since batch cannot issue a structure query mid-run to derive it", Default: "-1"},
+			{Name: "source-index", Kind: "own", Type: "int", Required: "optional", Desc: "Source position (0-based); optional. If omitted, the CLI runtime derives it from the current workbook index of `--sheet-id` / `--sheet-name`", Default: "-1"},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
 	},
@@ -983,7 +941,7 @@ var flagDefs = map[string]commandDef{
 		Flags: []flagDef{
 			{Name: "title", Kind: "own", Type: "string", Required: "required", Desc: "Spreadsheet title"},
 			{Name: "folder-token", Kind: "own", Type: "string", Required: "optional", Desc: "Target folder token; placed at the drive root when omitted"},
-			{Name: "values", Kind: "own", Type: "string", Required: "optional", Desc: "Untyped initial data as one 2D JSON array (`[[\"alice\",95]]`); values are written as-is with their type auto-detected (dates / numbers land as text — use --sheets to preserve types), through the same batched set_cell_range path as --sheets — pair with --styles for number formats, colors, merges, and row/col sizes", Input: []string{"file", "stdin"}},
+			{Name: "values", Kind: "own", Type: "string", Required: "optional", Desc: "Untyped initial data as one 2D JSON array (`[[\"alice\",95]]`); values are written as-is with their type auto-detected, through the same batched set_cell_range path as --sheets — pair with --styles for number formats, colors, merges, and row/col sizes", Input: []string{"file", "stdin"}},
 			{Name: "sheets", Kind: "own", Type: "string", Required: "optional", Desc: "Typed table payload as JSON (same shape as `+table-put`): top-level `{\"sheets\":[...]}`, with each array item a sub-sheet `{name, start_cell?, mode?, header?, allow_overwrite?, columns:[\"colA\",\"colB\",...], data:[[...]], dtypes?:{colA:pandasDtype, ...}, formats?:{colA:numberFormat, ...}}` — `name` and the outer `sheets` envelope are both required. Agents typically use `df_to_sheet(df, name)` from `scripts/sheets_df.py` to pack each DataFrame into one item, then wrap the list in `{\"sheets\":[...]}`. Mutually exclusive with --values. Creates the workbook, then writes typed type-faithful data (dates land as real dates, numbers keep precision).", Input: []string{"file", "stdin"}},
 			{Name: "styles", Kind: "own", Type: "string", Required: "optional", Desc: "Initial visual operations as JSON: top-level `{styles:[...]}`. Each item corresponds to one target sheet and must include `name`, plus at least one of `cell_styles` / `row_sizes` / `col_sizes` / `cell_merges`. `cell_styles` entries use +cells-set-style fields with a cell range; row/col sizes use dimension ranges plus type/size; merges use cell ranges plus optional merge_type. With --sheets, styles array length/order/name must match --sheets.sheets. With --values, pass exactly one styles item for the initial sheet (its name is ignored).", Input: []string{"file", "stdin"}},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},

shortcuts/sheets/helpers.go

@@ -50,42 +50,6 @@ func sheetsInputStatError(flag string, err error) error {
 	return wrapped
 }
 
-// Drive media parent_type values for uploading an image into a spreadsheet.
-// Native spreadsheets use "sheet_image"; imported "office" spreadsheets carry a
-// synthetic token prefixed with "fake_office_" and the backend requires
-// "office_sheet_file" instead.
-const (
-	sheetImageParentType      = "sheet_image"
-	officeSheetFileParentType = "office_sheet_file"
-	fakeOfficeTokenPrefix     = "fake_office_"
-)
-
-// sheetMediaParentType returns the drive media parent_type to use when
-// uploading an image whose parent_node is spreadsheetToken. It is the single
-// place that maps a spreadsheet token to its parent_type so every image-upload
-// entry point (and its dry-run preview) stays consistent.
-func sheetMediaParentType(spreadsheetToken string) string {
-	if strings.HasPrefix(spreadsheetToken, fakeOfficeTokenPrefix) {
-		return officeSheetFileParentType
-	}
-	return sheetImageParentType
-}
-
-// uploadSheetImage uploads a local image file as a spreadsheet media asset and
-// returns its file_token. It funnels every sheets image upload through one
-// place so the parent_type selection (see sheetMediaParentType) is never
-// duplicated or forgotten at a call site. Callers are expected to have already
-// resolved spreadsheetToken (the upload's parent_node) and stat'd the file.
-func uploadSheetImage(runtime *common.RuntimeContext, spreadsheetToken, filePath, fileName string, fileSize int64) (string, error) {
-	return common.UploadDriveMediaAllTyped(runtime, common.DriveMediaUploadAllConfig{
-		FilePath:   filePath,
-		FileName:   fileName,
-		FileSize:   fileSize,
-		ParentType: sheetMediaParentType(spreadsheetToken),
-		ParentNode: &spreadsheetToken,
-	})
-}
-
 // spreadsheetRef classification: a --url / --spreadsheet-token input names a
 // spreadsheet either directly (a /sheets/ URL or raw token) or indirectly via a
 // wiki node that must be resolved to its backing spreadsheet at Execute time.
@@ -440,7 +404,7 @@ func requireJSONArray(runtime flagView, name string) ([]interface{}, error) {
 
 // ─── style flags (shared by +cells-set-style and +cells-batch-set-style) ─
 
-// buildCellStyleFromFlags reads the 12 flat style flags and returns the
+// buildCellStyleFromFlags reads the 11 flat style flags and returns the
 // cell_styles map expected by set_cell_range. Skips any flag the user
 // didn't set so partial styles work.
 func buildCellStyleFromFlags(runtime flagView) map[string]interface{} {
@@ -451,9 +415,6 @@ func buildCellStyleFromFlags(runtime flagView) map[string]interface{} {
 	if v := runtime.Str("font-color"); v != "" {
 		style["font_color"] = v
 	}
-	if v := runtime.Str("font-family"); v != "" {
-		style["font_family"] = v
-	}
 	if runtime.Changed("font-size") && runtime.Float64("font-size") > 0 {
 		style["font_size"] = runtime.Float64("font-size")
 	}

shortcuts/sheets/lark_sheet_batch_update.go

@@ -215,8 +215,7 @@ func cellsBatchSetStyleInput(runtime *common.RuntimeContext, token string) (map[
 	if borderStyles != nil {
 		prototype["border_styles"] = borderStyles
 	}
-	ops := make([]interface{}, 0, len(ranges))
-	var totalCells int64
+	var ops []interface{}
 	for _, rng := range ranges {
 		sheet, sub, err := splitSheetPrefixedRange(rng)
 		if err != nil {
@@ -226,13 +225,6 @@ func cellsBatchSetStyleInput(runtime *common.RuntimeContext, token string) (map[
 		if err != nil {
 			return nil, sheetsValidationForFlag("range", "range %q: %v", rng, err)
 		}
-		if err := checkStampMatrixBudget("ranges", rng, rows, cols); err != nil {
-			return nil, err
-		}
-		totalCells += int64(rows) * int64(cols)
-		if err := checkBatchStampBudget(totalCells); err != nil {
-			return nil, err
-		}
 		cells := fillCellsMatrix(rows, cols, prototype)
 		ops = append(ops, map[string]interface{}{
 			"tool_name": "set_cell_range",
@@ -307,7 +299,7 @@ func cellsBatchClearInput(runtime *common.RuntimeContext, token string) (map[str
 		return nil, err
 	}
 	clearType := normalizeClearType(runtime.Str("scope"))
-	ops := make([]interface{}, 0, len(ranges))
+	var ops []interface{}
 	for _, rng := range ranges {
 		sheet, sub, err := splitSheetPrefixedRange(rng)
 		if err != nil {
@@ -390,10 +382,13 @@ var DropdownDelete = common.Shortcut{
 		if _, err := resolveSpreadsheetToken(runtime); err != nil {
 			return err
 		}
-		// validateDropdownRanges enforces the shared maxBatchRanges cap.
-		if _, err := validateDropdownRanges(runtime); err != nil {
+		ranges, err := validateDropdownRanges(runtime)
+		if err != nil {
 			return err
 		}
+		if len(ranges) > 100 {
+			return sheetsValidationForFlag("ranges", "--ranges accepts at most 100 entries; got %d", len(ranges))
+		}
 		return nil
 	},
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
@@ -437,8 +432,7 @@ func dropdownBatchInput(runtime *common.RuntimeContext, token string, clear bool
 		}
 		prototype = map[string]interface{}{"data_validation": validation}
 	}
-	ops := make([]interface{}, 0, len(ranges))
-	var totalCells int64
+	var ops []interface{}
 	for _, rng := range ranges {
 		sheet, sub, err := splitSheetPrefixedRange(rng)
 		if err != nil {
@@ -448,13 +442,6 @@ func dropdownBatchInput(runtime *common.RuntimeContext, token string, clear bool
 		if err != nil {
 			return nil, sheetsValidationForFlag("range", "range %q: %v", rng, err)
 		}
-		if err := checkStampMatrixBudget("ranges", rng, rows, cols); err != nil {
-			return nil, err
-		}
-		totalCells += int64(rows) * int64(cols)
-		if err := checkBatchStampBudget(totalCells); err != nil {
-			return nil, err
-		}
 		cells := fillCellsMatrix(rows, cols, prototype)
 		ops = append(ops, map[string]interface{}{
 			"tool_name": "set_cell_range",
@@ -474,25 +461,6 @@ func dropdownBatchInput(runtime *common.RuntimeContext, token string, clear bool
 
 // ─── helpers resurrected from B3 (used here + future skills) ──────────
 
-// maxBatchRanges caps how many ranges a fan-out batch (+cells-batch-set-style /
-// +cells-batch-clear / +dropdown-update / +dropdown-delete) may carry, bounding
-// the number of ops materialized into one batch_update.
-const maxBatchRanges = 100
-
-// checkBatchStampBudget rejects a fan-out batch whose ranges materialize more
-// than maxStampMatrixCells cells in aggregate. A batch builds every range's
-// cells matrix up front, so the SUM across ranges is the real peak-memory bound
-// — the per-range checkStampMatrixBudget alone can't stop many ranges from
-// summing past it. totalCells is int64 to stay overflow-safe.
-func checkBatchStampBudget(totalCells int64) error {
-	if totalCells > maxStampMatrixCells {
-		return sheetsValidationForFlag("ranges",
-			"ranges expand to %d cells total, over the %d-cell safety cap; reduce the number or size of ranges",
-			totalCells, maxStampMatrixCells)
-	}
-	return nil
-}
-
 // validateDropdownRanges parses --ranges, requires every entry to carry a
 // sheet prefix, and returns the parsed list.
 func validateDropdownRanges(runtime *common.RuntimeContext) ([]string, error) {
@@ -522,9 +490,6 @@ func validateDropdownRanges(runtime *common.RuntimeContext) ([]string, error) {
 		}
 		out = append(out, s)
 	}
-	if len(out) > maxBatchRanges {
-		return nil, sheetsValidationForFlag("ranges", "--ranges accepts at most %d entries; got %d", maxBatchRanges, len(out))
-	}
 	return out, nil
 }
 

shortcuts/sheets/lark_sheet_formula_verify.go

@@ -1,167 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package sheets
-
-import (
-	"context"
-	"strings"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/util"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// ─── lark_sheet_formula_verify ───────────────────────────────────────
-//
-// Wraps verify_formula (read): scan formulas + cell error states across one
-// or more sub-sheets and aggregate Excel errors (#REF! / #DIV/0! / #VALUE! /
-// #NAME? / #NULL! / #NUM! / #N/A) plus compile failures (formula_errors)
-// into a recalc.py-shaped JSON status report. The contract is the single
-// AI self-check entry point for the R10 "write → verify zero-error"
-// invariant — see canonical-spec/references/lark_sheet_formula_verify/.
-
-// FormulaVerify wraps verify_formula. Sheet selection is optional (both
-// --sheet-id and --sheet-name are repeatable); when omitted, the tool scans
-// every visible sub-sheet's current_region.
-var FormulaVerify = common.Shortcut{
-	Service:     "sheets",
-	Command:     "+formula-verify",
-	Description: "Scan formulas / cell errors and return a recalc.py-shaped status report (success / errors_found / partial).",
-	Risk:        "read",
-	Scopes:      []string{"sheets:spreadsheet:read"},
-	AuthTypes:   []string{"user", "bot"},
-	HasFormat:   true,
-	Flags:       flagsFor("+formula-verify"),
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		if _, err := resolveSpreadsheetToken(runtime); err != nil {
-			return err
-		}
-		if err := validateFormulaVerifySheetSelector(runtime); err != nil {
-			return err
-		}
-		return validateFormulaVerifyLimits(runtime)
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		token, _ := resolveSpreadsheetToken(runtime)
-		return invokeToolDryRun(token, ToolKindRead, "verify_formula", formulaVerifyInput(runtime, token))
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetTokenExec(runtime)
-		if err != nil {
-			return err
-		}
-		out, err := callTool(ctx, runtime, token, ToolKindRead, "verify_formula", formulaVerifyInput(runtime, token))
-		if err != nil {
-			return err
-		}
-		runtime.Out(out, nil)
-		if runtime.Bool("exit-on-error") {
-			return formulaVerifyExitOnError(out)
-		}
-		return nil
-	},
-}
-
-// validateFormulaVerifySheetSelector enforces XOR-like guarantees on the
-// two multi-value selectors: at most one of --sheet-id / --sheet-name may be
-// non-empty (passing both is the high-frequency reflex confusion when the
-// caller cargo-cults the single-sheet shortcut signature). Both empty is the
-// documented "scan every visible sub-sheet" path. Control-char checks reuse
-// requireSheetSelector's logic on each item.
-func validateFormulaVerifySheetSelector(runtime *common.RuntimeContext) error {
-	ids := nonEmptySliceItems(runtime.StrSlice("sheet-id"))
-	names := nonEmptySliceItems(runtime.StrSlice("sheet-name"))
-	if len(ids) > 0 && len(names) > 0 {
-		return common.ValidationErrorf("--sheet-id and --sheet-name are mutually exclusive; pick one selector to identify sub-sheets").
-			WithParams(
-				sheetsInvalidParam("sheet-id", "mutually exclusive"),
-				sheetsInvalidParam("sheet-name", "mutually exclusive"),
-			)
-	}
-	for _, id := range ids {
-		if err := requireSheetSelector(id, ""); err != nil {
-			return err
-		}
-	}
-	for _, name := range names {
-		if err := requireSheetSelector("", name); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// validateFormulaVerifyLimits rejects non-positive caps so a misplaced 0 or
-// negative flag value can't silently degrade the scan (the server-side
-// default would otherwise mask the typo).
-func validateFormulaVerifyLimits(runtime *common.RuntimeContext) error {
-	if runtime.Changed("max-locations") && runtime.Int("max-locations") <= 0 {
-		return sheetsValidationForFlag("max-locations", "--max-locations must be > 0")
-	}
-	return nil
-}
-
-// nonEmptySliceItems trims and drops blanks from a repeated-flag value so
-// `--sheet-id ""` doesn't masquerade as a real entry.
-func nonEmptySliceItems(in []string) []string {
-	out := make([]string, 0, len(in))
-	for _, v := range in {
-		if trimmed := strings.TrimSpace(v); trimmed != "" {
-			out = append(out, trimmed)
-		}
-	}
-	return out
-}
-
-// formulaVerifyInput builds the verify_formula tool input map from CLI flags.
-// excel_id is required; everything else is optional per the schema.
-func formulaVerifyInput(runtime *common.RuntimeContext, token string) map[string]interface{} {
-	input := map[string]interface{}{
-		"excel_id": token,
-	}
-	if ids := nonEmptySliceItems(runtime.StrSlice("sheet-id")); len(ids) > 0 {
-		input["sheet_ids"] = ids
-	} else if names := nonEmptySliceItems(runtime.StrSlice("sheet-name")); len(names) > 0 {
-		// The verify_formula schema only declares sheet_ids; the facade
-		// accepts sheet_names as a parallel optional field so name-based
-		// selection works without forcing the caller to pre-resolve. Mirrors
-		// how the other read shortcuts pack both fields via
-		// sheetSelectorForToolInput.
-		input["sheet_names"] = names
-	}
-	if ranges := nonEmptySliceItems(runtime.StrSlice("range")); len(ranges) > 0 {
-		input["ranges"] = ranges
-	}
-	if runtime.Changed("max-locations") {
-		input["max_locations_per_error"] = runtime.Int("max-locations")
-	}
-	return input
-}
-
-// formulaVerifyExitOnError converts a verify_formula status into a non-zero
-// CLI exit when the caller passed --exit-on-error. status="errors_found"
-// is the only failure mode for this flag: "partial" means truncated but the
-// scanned slice is clean, and "success" is obviously clean. A missing /
-// unknown status is treated as a typed internal error because the tool's
-// schema guarantees the field and we don't want a silent zero-exit.
-func formulaVerifyExitOnError(out interface{}) error {
-	m, ok := out.(map[string]interface{})
-	if !ok {
-		return errs.NewInternalError(errs.SubtypeInvalidResponse,
-			"verify_formula: missing status field in tool output")
-	}
-	status, _ := m["status"].(string)
-	switch status {
-	case "success", "partial":
-		return nil
-	case "errors_found":
-		total, _ := util.ToFloat64(m["total_errors"])
-		return errs.NewValidationError(errs.SubtypeFailedPrecondition,
-			"verify_formula: %d formula error(s) detected; resolve and re-run", int(total)).
-			WithHint("inspect error_summary[*] / compile_errors[*] in the JSON output, fix or wrap with IFERROR, then re-run +formula-verify until status=success")
-	default:
-		return errs.NewInternalError(errs.SubtypeInvalidResponse,
-			"verify_formula: unexpected status %q", status)
-	}
-}

shortcuts/sheets/lark_sheet_formula_verify_test.go

@@ -1,213 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package sheets
-
-import (
-	"errors"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-)
-
-// TestFormulaVerify_DryRun pins the wire shape verify_formula sends for the
-// common input combinations: no selector (workbook-wide scan), explicit
-// sheet_ids, explicit ranges, and the optional max_locations_per_error
-// field. The test exercises the One-OpenAPI body
-// directly so the schema field names stay locked to the canonical
-// tool-schemas.json verify_formula node.
-func TestFormulaVerify_DryRun(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name      string
-		args      []string
-		wantInput map[string]interface{}
-	}{
-		{
-			name: "no selector — workbook-wide scan defaults",
-			args: []string{"--url", testURL},
-			wantInput: map[string]interface{}{
-				"excel_id": testToken,
-			},
-		},
-		{
-			name: "sheet_ids multi via repeat",
-			args: []string{"--url", testURL, "--sheet-id", testSheetID, "--sheet-id", testSheetID2},
-			wantInput: map[string]interface{}{
-				"excel_id":  testToken,
-				"sheet_ids": []interface{}{testSheetID, testSheetID2},
-			},
-		},
-		{
-			name: "sheet_names multi via comma",
-			args: []string{"--url", testURL, "--sheet-name", "Sheet1,Sheet2"},
-			wantInput: map[string]interface{}{
-				"excel_id":    testToken,
-				"sheet_names": []interface{}{"Sheet1", "Sheet2"},
-			},
-		},
-		{
-			name: "ranges + max_locations",
-			args: []string{
-				"--url", testURL,
-				"--range", "A1:Z200",
-				"--range", "AA1:AZ100",
-				"--max-locations", "5",
-			},
-			wantInput: map[string]interface{}{
-				"excel_id":                testToken,
-				"ranges":                  []interface{}{"A1:Z200", "AA1:AZ100"},
-				"max_locations_per_error": float64(5),
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			body := parseDryRunBody(t, FormulaVerify, tt.args)
-			got := decodeToolInput(t, body, "verify_formula")
-			assertInputEquals(t, got, tt.wantInput)
-		})
-	}
-}
-
-// TestFormulaVerify_DryRunInvokeReadPath confirms the request hits
-// invoke_read (read scope) and not invoke_write — a scope mismatch here would
-// surface as a 403 from the gateway.
-func TestFormulaVerify_DryRunInvokeReadPath(t *testing.T) {
-	t.Parallel()
-	calls := parseDryRunAPI(t, FormulaVerify, []string{"--url", testURL})
-	if len(calls) == 0 {
-		t.Fatalf("dry-run produced no api calls")
-	}
-	call, _ := calls[0].(map[string]interface{})
-	url, _ := call["url"].(string)
-	if !strings.HasSuffix(url, "/tools/invoke_read") {
-		t.Errorf("verify_formula must hit invoke_read; got url=%q", url)
-	}
-	if want := "/open-apis/sheet_ai/v2/spreadsheets/" + testToken + "/tools/invoke_read"; url != want {
-		t.Errorf("url = %q, want %q", url, want)
-	}
-}
-
-// TestFormulaVerify_RejectsBothSelectors locks the "at most one selector"
-// rule on the two multi-value flags. Both empty is the documented
-// workbook-wide scan path, so we only reject the both-supplied case.
-func TestFormulaVerify_RejectsBothSelectors(t *testing.T) {
-	t.Parallel()
-	_, _, err := runShortcutCapturingErr(t, FormulaVerify, []string{
-		"--url", testURL,
-		"--sheet-id", testSheetID,
-		"--sheet-name", "Sheet1",
-		"--dry-run",
-	})
-	ve := requireValidation(t, err, "mutually exclusive")
-	gotParams := map[string]bool{}
-	for _, p := range ve.Params {
-		gotParams[p.Name] = true
-	}
-	if !gotParams["--sheet-id"] || !gotParams["--sheet-name"] {
-		t.Errorf("params = %#v, want both --sheet-id and --sheet-name flagged", ve.Params)
-	}
-}
-
-// TestFormulaVerify_RejectsNonPositiveLimits guards against typos like
-// `--max-locations 0`, which would otherwise be silently swallowed by the
-// "explicit value but unset" comparison in the input builder.
-func TestFormulaVerify_RejectsNonPositiveLimits(t *testing.T) {
-	t.Parallel()
-	cases := []struct {
-		name string
-		args []string
-		want string
-	}{
-		{
-			name: "max-locations=0",
-			args: []string{"--url", testURL, "--max-locations", "0"},
-			want: "--max-locations must be > 0",
-		},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			t.Parallel()
-			_, _, err := runShortcutCapturingErr(t, FormulaVerify, append(c.args, "--dry-run"))
-			requireValidation(t, err, c.want)
-		})
-	}
-}
-
-// TestFormulaVerifyExitOnError_StatusMatrix locks the --exit-on-error
-// contract: success/partial → no error; errors_found → typed validation
-// error with SubtypeFailedPrecondition; missing or unknown status →
-// typed internal error so a silent zero-exit can never happen.
-func TestFormulaVerifyExitOnError_StatusMatrix(t *testing.T) {
-	t.Parallel()
-
-	t.Run("success returns no error", func(t *testing.T) {
-		t.Parallel()
-		if err := formulaVerifyExitOnError(map[string]interface{}{"status": "success"}); err != nil {
-			t.Fatalf("success path returned err: %v", err)
-		}
-	})
-
-	t.Run("partial returns no error", func(t *testing.T) {
-		t.Parallel()
-		if err := formulaVerifyExitOnError(map[string]interface{}{"status": "partial", "has_more": true}); err != nil {
-			t.Fatalf("partial path returned err: %v", err)
-		}
-	})
-
-	t.Run("errors_found yields failed_precondition with count", func(t *testing.T) {
-		t.Parallel()
-		err := formulaVerifyExitOnError(map[string]interface{}{
-			"status":       "errors_found",
-			"total_errors": float64(7),
-		})
-		if err == nil {
-			t.Fatal("expected error, got nil")
-		}
-		var ve *errs.ValidationError
-		if !errors.As(err, &ve) {
-			t.Fatalf("error = %T %v, want *errs.ValidationError", err, err)
-		}
-		if ve.Subtype != errs.SubtypeFailedPrecondition {
-			t.Errorf("subtype = %q, want %q", ve.Subtype, errs.SubtypeFailedPrecondition)
-		}
-		if !strings.Contains(ve.Message, "7 formula error") {
-			t.Errorf("message %q must surface the error count", ve.Message)
-		}
-		if ve.Hint == "" {
-			t.Errorf("hint must be set so AI agents know to re-run after fixes")
-		}
-	})
-
-	t.Run("unknown status maps to internal/invalid_response", func(t *testing.T) {
-		t.Parallel()
-		err := formulaVerifyExitOnError(map[string]interface{}{"status": "weird"})
-		if err == nil {
-			t.Fatal("expected error, got nil")
-		}
-		p, ok := errs.ProblemOf(err)
-		if !ok {
-			t.Fatalf("expected typed problem, got %T %v", err, err)
-		}
-		if p.Category != errs.CategoryInternal || p.Subtype != errs.SubtypeInvalidResponse {
-			t.Errorf("category/subtype = %q/%q, want internal/invalid_response", p.Category, p.Subtype)
-		}
-	})
-
-	t.Run("non-object output maps to internal/invalid_response", func(t *testing.T) {
-		t.Parallel()
-		err := formulaVerifyExitOnError("oops")
-		p, ok := errs.ProblemOf(err)
-		if !ok {
-			t.Fatalf("expected typed problem, got %T %v", err, err)
-		}
-		if p.Category != errs.CategoryInternal || p.Subtype != errs.SubtypeInvalidResponse {
-			t.Errorf("category/subtype = %q/%q, want internal/invalid_response", p.Category, p.Subtype)
-		}
-	})
-}

shortcuts/sheets/lark_sheet_history_list.go

@@ -1,97 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package sheets
-
-import (
-	"context"
-
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// ─── lark_sheet_history (BE-1: +history-list) ─────────────────────────
-//
-// Wraps the facade-agg `history_list` tool (read) behind the One-OpenAPI
-// invoke_read endpoint. The tool returns a sheet's version history. The
-// facade-agg tool already performs the response transform (minor_histories
-// trim / id → history_version_id / 4-field projection / RFC3339 create_time),
-// so the CLI passes the tool output straight through and does NOT re-implement
-// the transform client-side.
-//
-// History is workbook-level (no sheet selector), mirroring +workbook-info:
-// the only locator is --url / --spreadsheet-token (XOR), with --token accepted
-// as a parse-time alias for --spreadsheet-token via the shared PostMount hook.
-//
-// Flags are declared inline here rather than via flagsFor(): the generated
-// flag_defs_gen.go / data/flag-defs.json are synced from sheet-skill-spec
-// (BE-3) and must not be hand-edited, so this hand-written shortcut owns its
-// own flag set. The two locator flags match +workbook-info's shape exactly.
-
-// historyLocatorFlags is the --url / --spreadsheet-token XOR locator pair
-// shared by the three history shortcuts. Mirrors +workbook-info's flag-defs
-// entry; XOR is enforced in Validate via parseSpreadsheetRef, not by Required.
-func historyLocatorFlags() []common.Flag {
-	return []common.Flag{
-		{Name: "url", Type: "string", Desc: "Spreadsheet locator (a /sheets/ or /wiki/ URL)."},
-		{Name: "spreadsheet-token", Type: "string", Desc: "Spreadsheet locator (raw spreadsheet token)."},
-	}
-}
-
-// HistoryList wraps the history_list tool: list a spreadsheet's history
-// versions. Each item carries history_version_id / create_time / action /
-// all_block_revision (projected server-side). An empty sheet yields an empty
-// list and exit 0.
-//
-// Backward pagination: --end-version (optional int) maps to the tool's
-// `end_version` parameter. Omit on the first call to fetch the latest page.
-// On subsequent pages pass the previous response's next_end_version as
-// --end-version. The tool returns next_end_version + has_more only when
-// more history exists; both fields are absent at the earliest page.
-var HistoryList = common.Shortcut{
-	Service:     "sheets",
-	Command:     "+history-list",
-	Description: "List a spreadsheet's edit history versions (history_version_id, create_time, action, all_block_revision).",
-	Risk:        "read",
-	Scopes:      []string{"sheets:spreadsheet:read"},
-	AuthTypes:   []string{"user", "bot"},
-	HasFormat:   true,
-	Flags: append(historyLocatorFlags(),
-		common.Flag{Name: "end-version", Type: "int", Desc: "Max version to query (descending pagination). Omit on the first call; pass the previous response's next_end_version on subsequent pages."},
-	),
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		_, err := resolveSpreadsheetToken(runtime)
-		return err
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		token, _ := resolveSpreadsheetToken(runtime)
-		return invokeToolDryRun(token, ToolKindRead, "history_list", historyListInput(runtime, token))
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetTokenExec(runtime)
-		if err != nil {
-			return err
-		}
-		out, err := callTool(ctx, runtime, token, ToolKindRead, "history_list", historyListInput(runtime, token))
-		if err != nil {
-			return err
-		}
-		// Pass the tool output through verbatim — facade-agg already shaped it.
-		runtime.Out(out, nil)
-		return nil
-	},
-	Tips: []string{
-		"Capture a history_version_id from the result to feed +history-revert.",
-		"For older history, capture next_end_version from the response and pass it as --end-version on the next call (omitted by the server when the earliest page is reached).",
-	},
-}
-
-// historyListInput composes the history_list tool input. --end-version is
-// optional: include it only when explicitly set so the server treats absence
-// as "first page (latest)".
-func historyListInput(runtime *common.RuntimeContext, token string) map[string]interface{} {
-	in := map[string]interface{}{"excel_id": token}
-	if runtime.Changed("end-version") {
-		in["end_version"] = runtime.Int("end-version")
-	}
-	return in
-}