agent-trellis 0.7.0 → 0.8.2

package/dist/lib/taskStore.d.ts

@@ -0,0 +1,46 @@
+import type { AgentId } from "../core/types.js";
+export type TaskStatus = "pending" | "claimed" | "in_progress" | "blocked" | "completed";
+export interface TaskContext {
+    workspace?: string;
+    commit?: string;
+    references?: string[];
+    note?: string;
+}
+export interface TaskHistoryEntry {
+    at: string;
+    agent: AgentId;
+    action: string;
+    status: TaskStatus;
+    note?: string;
+}
+export interface TaskRecord {
+    id: string;
+    objective: string;
+    fromAgent: AgentId;
+    toAgent?: AgentId;
+    status: TaskStatus;
+    context?: TaskContext;
+    constraints?: string[];
+    result?: string;
+    claimedBy?: AgentId;
+    leaseUntil?: string;
+    createdAt: string;
+    updatedAt: string;
+    history: TaskHistoryEntry[];
+}
+export declare function taskStorePath(homeDir: string): string;
+export declare function listTasks(homeDir: string, filter?: {
+    status?: TaskStatus;
+    toAgent?: AgentId;
+}): TaskRecord[];
+export declare function readTask(homeDir: string, id: string): TaskRecord;
+export declare function createTask(homeDir: string, input: {
+    objective: string;
+    fromAgent: AgentId;
+    toAgent?: AgentId;
+    context?: TaskContext;
+    constraints?: string[];
+}): TaskRecord;
+export declare function claimTask(homeDir: string, id: string, agent: AgentId, leaseMs?: number): TaskRecord;
+export declare function updateTask(homeDir: string, id: string, agent: AgentId, status: TaskStatus, note?: string, result?: string): TaskRecord;
+export declare function handoffTask(homeDir: string, id: string, agent: AgentId, toAgent: AgentId, note?: string): TaskRecord;

package/dist/lib/taskStore.js

@@ -0,0 +1,156 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+const SECRET_LIKE = /(sk-|ghp_|glpat-|mcpr_|token\s*=|password\s*=|secret\s*=|authorization\s*:)/i;
+export function taskStorePath(homeDir) {
+    return join(homeDir, ".trellis", "tasks", "tasks.json");
+}
+function readFile(path) {
+    if (!existsSync(path))
+        return { tasks: [] };
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        return { tasks: Array.isArray(value.tasks) ? value.tasks : [] };
+    }
+    catch {
+        throw new Error(`could not parse task store ${path}`);
+    }
+}
+function writeFile(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    const temporary = `${path}.${process.pid}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    renameSync(temporary, path);
+}
+function assertSafeText(label, value) {
+    if (!value.trim())
+        throw new Error(`${label} must not be empty`);
+    if (SECRET_LIKE.test(value))
+        throw new Error(`${label} looks like it contains a credential or secret-like value`);
+}
+function assertSafeContext(context) {
+    if (!context)
+        return;
+    for (const [key, value] of Object.entries(context)) {
+        if (typeof value === "string")
+            assertSafeText(`context.${key}`, value);
+        if (Array.isArray(value))
+            value.forEach((item) => assertSafeText(`context.${key}`, item));
+    }
+}
+function now() {
+    return new Date().toISOString();
+}
+function assertAgent(value, label) {
+    if (value !== "claude-code" && value !== "codex" && value !== "kiro" && value !== "pi" && value !== "kimi-code" && value !== "zcode") {
+        throw new Error(`${label} must be a supported Agent id`);
+    }
+}
+function taskOrThrow(file, id) {
+    const task = file.tasks.find((candidate) => candidate.id === id);
+    if (!task)
+        throw new Error(`task "${id}" was not found`);
+    return task;
+}
+function addHistory(task, agent, action, status, note) {
+    task.status = status;
+    task.updatedAt = now();
+    task.history.push({ at: task.updatedAt, agent, action, status, ...(note ? { note } : {}) });
+}
+export function listTasks(homeDir, filter) {
+    const tasks = readFile(taskStorePath(homeDir)).tasks;
+    return tasks
+        .filter((task) => !filter?.status || task.status === filter.status)
+        .filter((task) => !filter?.toAgent || task.toAgent === filter.toAgent)
+        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+export function readTask(homeDir, id) {
+    return taskOrThrow(readFile(taskStorePath(homeDir)), id);
+}
+export function createTask(homeDir, input) {
+    assertSafeText("objective", input.objective);
+    assertAgent(input.fromAgent, "fromAgent");
+    if (input.toAgent)
+        assertAgent(input.toAgent, "toAgent");
+    assertSafeContext(input.context);
+    input.constraints?.forEach((value) => assertSafeText("constraint", value));
+    const timestamp = now();
+    const task = {
+        id: `task-${randomUUID()}`,
+        objective: input.objective,
+        fromAgent: input.fromAgent,
+        ...(input.toAgent ? { toAgent: input.toAgent } : {}),
+        status: "pending",
+        ...(input.context ? { context: input.context } : {}),
+        ...(input.constraints?.length ? { constraints: input.constraints } : {}),
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        history: [{ at: timestamp, agent: input.fromAgent, action: "created", status: "pending" }],
+    };
+    const file = readFile(taskStorePath(homeDir));
+    file.tasks.push(task);
+    writeFile(taskStorePath(homeDir), file);
+    return task;
+}
+export function claimTask(homeDir, id, agent, leaseMs = 30 * 60 * 1000) {
+    assertAgent(agent, "agent");
+    if (!Number.isFinite(leaseMs) || leaseMs < 1_000 || leaseMs > 24 * 60 * 60 * 1000)
+        throw new Error("leaseMs must be between 1000 and 86400000");
+    const path = taskStorePath(homeDir);
+    const file = readFile(path);
+    const task = taskOrThrow(file, id);
+    const timestamp = Date.now();
+    if (task.leaseUntil && new Date(task.leaseUntil).getTime() <= timestamp) {
+        task.claimedBy = undefined;
+        task.leaseUntil = undefined;
+        if (task.status === "claimed" || task.status === "in_progress")
+            task.status = "pending";
+    }
+    if (task.status !== "pending" || task.claimedBy)
+        throw new Error(`task "${id}" is already claimed or is not pending`);
+    task.claimedBy = agent;
+    task.leaseUntil = new Date(timestamp + leaseMs).toISOString();
+    addHistory(task, agent, "claimed", "claimed");
+    writeFile(path, file);
+    return task;
+}
+export function updateTask(homeDir, id, agent, status, note, result) {
+    assertAgent(agent, "agent");
+    if (!["pending", "claimed", "in_progress", "blocked", "completed"].includes(status))
+        throw new Error(`invalid task status "${status}"`);
+    if (note)
+        assertSafeText("note", note);
+    if (result)
+        assertSafeText("result", result);
+    const path = taskStorePath(homeDir);
+    const file = readFile(path);
+    const task = taskOrThrow(file, id);
+    if (task.claimedBy && task.claimedBy !== agent)
+        throw new Error(`task "${id}" is claimed by another Agent`);
+    if (status === "completed" && result)
+        task.result = result;
+    addHistory(task, agent, status === "completed" ? "completed" : "updated", status, note);
+    if (status === "completed") {
+        task.claimedBy = undefined;
+        task.leaseUntil = undefined;
+    }
+    writeFile(path, file);
+    return task;
+}
+export function handoffTask(homeDir, id, agent, toAgent, note) {
+    assertAgent(agent, "agent");
+    assertAgent(toAgent, "toAgent");
+    if (note)
+        assertSafeText("note", note);
+    const path = taskStorePath(homeDir);
+    const file = readFile(path);
+    const task = taskOrThrow(file, id);
+    if (task.claimedBy && task.claimedBy !== agent)
+        throw new Error(`task "${id}" is claimed by another Agent`);
+    task.toAgent = toAgent;
+    task.claimedBy = undefined;
+    task.leaseUntil = undefined;
+    addHistory(task, agent, "handed-off", "pending", note);
+    writeFile(path, file);
+    return task;
+}

package/dist/lib/terminalPicker.d.ts

@@ -1,66 +1,40 @@
 /**
- * Minimal, dependency-free arrow-key/checkbox terminal picker
- * (trellis-onboard-interactive-picker design.md D1) — the interaction
- * surface `trellis onboard`'s two prompts need (at most four rows, no
- * search, no pagination) doesn't need a full prompt library; this
- * hand-rolls just enough raw-mode key handling and ANSI rendering for
- * that bounded case, matching the project's existing narrow-dependency
- * precedent (src/lib/envVarNames.ts, src/lib/secretEnv.ts).
+ * Styled interactive prompts used by `trellis onboard`.
  *
- * `input`/`output` are injectable (never a CLI flag) purely so tests can
- * drive the real key-parsing/render loop against a plain stream instead
- * of a real TTY — same seam pattern (`homeDir`, etc.) used everywhere
- * else in this project.
+ * The onboarding orchestration depends on semantic values (an index or a set
+ * of indices), not on a particular terminal renderer. Clack owns raw-mode
+ * handling, color, wrapping, cursor cleanup, and cancellation; the injected
+ * streams keep the prompt loop testable without a real terminal.
  */
 import type { Readable, Writable } from "node:stream";
 export interface PickerStreams {
     input: NodeJS.ReadStream | Readable;
     output: NodeJS.WriteStream | Writable;
 }
+export interface PickerOption {
+    label: string;
+    disabled?: boolean;
+}
 /**
- * True only when both streams are real, raw-mode-capable terminals — the
- * exact gate deciding picker vs. the pre-existing numbered-typing prompt
- * (design.md D2). A stream lacking `setRawMode` (piped input, some
- * minimal TTYs) always falls back, never hangs or guesses.
+ * Clack is only started for a real interactive terminal. Piped input keeps
+ * the existing numbered fallback in onboard instead of hanging in raw mode.
  */
 export declare function canUseInteractivePicker(streams?: PickerStreams): boolean;
-/** Wrapping index navigation — pure, exported for direct unit testing. */
+/** Wrapping index navigation retained as a small public utility for callers/tests. */
 export declare function nextIndex(current: number, delta: number, length: number): number;
-/** Pure single-index toggle — exported for direct unit testing. */
+/** Pure single-index toggle retained for callers/tests. */
 export declare function toggled(checked: readonly boolean[], index: number): boolean[];
-/** A row's *visible* width, excluding the color codes wrapped around it —
- * they add characters that occupy zero terminal columns. Needed to
- * compute how many physical lines a row actually wraps to (see
- * `physicalLineCount`); counting `row.length` directly would overcount
- * and under-clear on the next redraw. */
-export declare function visibleWidth(row: string): number;
-/**
- * How many physical terminal lines one logical row occupies once the
- * terminal wraps it — `Math.ceil(visibleWidth / columns)`, at least 1.
- * `clearLines`/`moveCursorUp` need this, not `rows.length`: a picker
- * item whose rendered text is longer than the terminal is wide (a long
- * agent summary, a narrow terminal, or both) wraps onto more than one
- * physical line, and erasing/moving by the *logical* row count instead
- * leaves the wrapped remainder of the previous frame on screen — found
- * via a real mirasim terminal session where a (much longer,
- * pre-truncation) row's wrapped tail was never cleared, so every redraw
- * appended a new, only-partially-overwritten copy instead of replacing
- * the old one.
- */
-export declare function physicalLineCount(row: string, columns: number): number;
-export declare function totalPhysicalLines(rows: readonly string[], columns: number): number;
 /**
- * Single-select: Up/Down/j/k moves the highlight, Enter confirms. Resolves
- * the confirmed index, or `null` on Ctrl+C cancel. Caller (onboard.ts)
- * must have already confirmed `canUseInteractivePicker()` — this function
- * does not re-check, and assumes `streams.input` genuinely supports raw
- * mode.
+ * Single-select prompt. The returned number is the original item index, so
+ * callers do not depend on display labels or prompt-library values.
  */
-export declare function runSingleSelectPicker(items: string[], streams?: PickerStreams): Promise<number | null>;
+export declare function runSingleSelectPicker(items: readonly (string | PickerOption)[], streams?: PickerStreams, message?: string): Promise<number | null>;
 /**
- * Multi-select (checkbox): Up/Down/j/k moves the highlight, Space toggles
- * the current row, Enter confirms. Resolves the checked indices at
- * confirm time, or `null` on Ctrl+C cancel. Same precondition as
- * `runSingleSelectPicker`.
+ * Checkbox prompt. The returned indices preserve the existing onboard
+ * contract, while Clack handles checked state, wrapping, colors, and cleanup.
  */
-export declare function runMultiSelectPicker(items: string[], initiallyChecked: readonly boolean[], streams?: PickerStreams): Promise<number[] | null>;
+export declare function runMultiSelectPicker(items: string[], initiallyChecked: readonly boolean[], streams?: PickerStreams, message?: string): Promise<number[] | null>;
+/** Searchable multiselect for large skill/MCP inventories. It returns the
+ * selected labels as stable names, preserving the semantic adapter contract
+ * while avoiding a wall of dozens of rows in the onboarding terminal. */
+export declare function runSearchMultiSelectPicker(items: readonly string[], streams?: PickerStreams, message?: string): Promise<string[] | null>;

package/dist/lib/terminalPicker.js

@@ -1,248 +1,110 @@
 /**
- * Minimal, dependency-free arrow-key/checkbox terminal picker
- * (trellis-onboard-interactive-picker design.md D1) — the interaction
- * surface `trellis onboard`'s two prompts need (at most four rows, no
- * search, no pagination) doesn't need a full prompt library; this
- * hand-rolls just enough raw-mode key handling and ANSI rendering for
- * that bounded case, matching the project's existing narrow-dependency
- * precedent (src/lib/envVarNames.ts, src/lib/secretEnv.ts).
+ * Styled interactive prompts used by `trellis onboard`.
  *
- * `input`/`output` are injectable (never a CLI flag) purely so tests can
- * drive the real key-parsing/render loop against a plain stream instead
- * of a real TTY — same seam pattern (`homeDir`, etc.) used everywhere
- * else in this project.
+ * The onboarding orchestration depends on semantic values (an index or a set
+ * of indices), not on a particular terminal renderer. Clack owns raw-mode
+ * handling, color, wrapping, cursor cleanup, and cancellation; the injected
+ * streams keep the prompt loop testable without a real terminal.
  */
+/**
+ * `@clack/prompts` (and its `@clack/core` dependency) is loaded lazily,
+ * inside each picker function below, rather than via a top-level
+ * `import` — deliberately, not an oversight. A top-level import runs the
+ * moment ANY module that transitively imports this file is evaluated,
+ * which for `trellis-gui`'s sidecar means every process start, since
+ * `onboard.ts` (imported unconditionally by the sidecar's `/plan/onboard`
+ * route) imports these functions even though the sidecar's `json: true`
+ * contract (see `planApply.ts`'s `OnboardWizardInput` doc comment)
+ * guarantees they are never actually called. Compiling the sidecar to a
+ * single-file binary (tasks.md 5.1) surfaced a real, current limitation
+ * in `@yao-pkg/pkg`'s ESM support: `@clack/prompts`' `exports`-map
+ * `.mjs` entry fails to resolve inside pkg's snapshot filesystem
+ * (`Cannot find module '.../@clack/prompts/dist/index.mjs'`), which
+ * previously crashed the packaged sidecar at startup even though its own
+ * code never uses the interactive picker at all. A dynamic `import()`
+ * only resolves at the point it actually runs, so the sidecar (whose
+ * `!opts.json` gates keep every real call site below unreached) never
+ * triggers that resolution attempt — while a real, interactive CLI run
+ * (`tsx`/`node`, not a pkg snapshot) resolves the dynamic import exactly
+ * as it would a static one, so this is behavior-preserving for the CLI.
+ */
+async function clack() {
+    return import("@clack/prompts");
+}
 function defaultStreams() {
-    return { input: process.stdin, output: process.stdout };
+    return { input: process.stdin, output: process.stderr };
 }
 /**
- * True only when both streams are real, raw-mode-capable terminals — the
- * exact gate deciding picker vs. the pre-existing numbered-typing prompt
- * (design.md D2). A stream lacking `setRawMode` (piped input, some
- * minimal TTYs) always falls back, never hangs or guesses.
+ * Clack is only started for a real interactive terminal. Piped input keeps
+ * the existing numbered fallback in onboard instead of hanging in raw mode.
  */
 export function canUseInteractivePicker(streams = defaultStreams()) {
     const input = streams.input;
     const output = streams.output;
     return Boolean(input.isTTY && output.isTTY && typeof input.setRawMode === "function");
 }
-/** Wrapping index navigation — pure, exported for direct unit testing. */
+/** Wrapping index navigation retained as a small public utility for callers/tests. */
 export function nextIndex(current, delta, length) {
     return ((current + delta) % length + length) % length;
 }
-/** Pure single-index toggle — exported for direct unit testing. */
+/** Pure single-index toggle retained for callers/tests. */
 export function toggled(checked, index) {
     const next = [...checked];
     next[index] = !next[index];
     return next;
 }
-const ESC = "\u001b";
-const CTRL_C = "\u0003";
-const HIDE_CURSOR = `${ESC}[?25l`;
-const SHOW_CURSOR = `${ESC}[?25h`;
-const ANSI_ESCAPE_RE = /\x1b\[[0-9;]*m/g;
-/** A row's *visible* width, excluding the color codes wrapped around it —
- * they add characters that occupy zero terminal columns. Needed to
- * compute how many physical lines a row actually wraps to (see
- * `physicalLineCount`); counting `row.length` directly would overcount
- * and under-clear on the next redraw. */
-export function visibleWidth(row) {
-    return row.replace(ANSI_ESCAPE_RE, "").length;
+function wasCancelled(value, cancelSymbol, isCancelFn) {
+    return value === cancelSymbol || isCancelFn(value);
 }
 /**
- * How many physical terminal lines one logical row occupies once the
- * terminal wraps it — `Math.ceil(visibleWidth / columns)`, at least 1.
- * `clearLines`/`moveCursorUp` need this, not `rows.length`: a picker
- * item whose rendered text is longer than the terminal is wide (a long
- * agent summary, a narrow terminal, or both) wraps onto more than one
- * physical line, and erasing/moving by the *logical* row count instead
- * leaves the wrapped remainder of the previous frame on screen — found
- * via a real mirasim terminal session where a (much longer,
- * pre-truncation) row's wrapped tail was never cleared, so every redraw
- * appended a new, only-partially-overwritten copy instead of replacing
- * the old one.
+ * Single-select prompt. The returned number is the original item index, so
+ * callers do not depend on display labels or prompt-library values.
  */
-export function physicalLineCount(row, columns) {
-    if (columns <= 0)
-        return 1;
-    return Math.max(1, Math.ceil(visibleWidth(row) / columns));
-}
-export function totalPhysicalLines(rows, columns) {
-    return rows.reduce((sum, row) => sum + physicalLineCount(row, columns), 0);
-}
-/** `output.columns` only exists on a real TTY; test-injected plain
- * streams (`PickerStreams`) have none. Defaulting to 80 — the standard
- * terminal width, and this project's own test fixtures — keeps the
- * wrap-aware math above exercised (and testable) even without a real
- * terminal, rather than silently reverting to "assume no row ever wraps"
- * for every non-TTY stream. */
-function columnsOf(output) {
-    return output.columns ?? 80;
-}
-/** Parses one raw input chunk into a single logical key — arrow escape
- * sequences, j/k, space, enter, or Ctrl+C. Anything else is ignored. */
-function parseKey(chunk) {
-    if (chunk === CTRL_C)
-        return "cancel";
-    if (chunk === "\r" || chunk === "\n")
-        return "confirm";
-    if (chunk === " ")
-        return "toggle";
-    if (chunk === `${ESC}[A` || chunk === "k")
-        return "up";
-    if (chunk === `${ESC}[B` || chunk === "j")
-        return "down";
-    return null;
-}
-function withRawMode(streams, body) {
-    const input = streams.input;
-    const output = streams.output;
-    const canSetRawMode = typeof input.setRawMode === "function";
-    if (canSetRawMode)
-        input.setRawMode(true);
-    input.resume();
-    input.setEncoding("utf-8");
-    output.write(HIDE_CURSOR);
-    const restore = () => {
-        output.write(SHOW_CURSOR);
-        if (canSetRawMode)
-            input.setRawMode(false);
-        input.pause();
-    };
-    // Second-layer safety net (design.md D6): a thrown error the caller's
-    // own try/finally doesn't get a chance to run for (process killed
-    // externally) must still not leave the terminal in raw mode/cursor
-    // hidden.
-    process.once("exit", restore);
-    return body().finally(() => {
-        restore();
-        process.removeListener("exit", restore);
+export async function runSingleSelectPicker(items, streams = defaultStreams(), message = "请选择一个迁移来源") {
+    const { select, CANCEL_SYMBOL, isCancel } = await clack();
+    const result = await select({
+        message,
+        options: items.map((item, value) => ({
+            label: typeof item === "string" ? item : item.label,
+            value,
+            ...(typeof item === "string" || item.disabled === undefined ? {} : { disabled: item.disabled }),
+        })),
+        input: streams.input,
+        output: streams.output,
+        showInstructions: true,
     });
-}
-function moveCursorUp(output, lines) {
-    if (lines > 0)
-        output.write(`${ESC}[${lines}A`);
-}
-function clearLines(output, lines) {
-    for (let i = 0; i < lines; i++) {
-        output.write(`${ESC}[2K`);
-        if (i < lines - 1)
-            output.write(`${ESC}[1B`);
-    }
-    moveCursorUp(output, lines - 1);
-}
-/**
- * `previousPhysicalLines` must be the actual on-screen line count the
- * *previous* call to this function produced (`totalPhysicalLines` of
- * that frame's rows), not `rows.length` — see `physicalLineCount`'s doc
- * comment for why a wrapped row makes those two numbers diverge.
- */
-function renderRows(output, rows, previousPhysicalLines) {
-    if (previousPhysicalLines > 0) {
-        clearLines(output, previousPhysicalLines);
-    }
-    for (const row of rows) {
-        output.write(`${row}\n`);
-    }
-}
-/**
- * A real foreground color (bold cyan), not just reverse video —
- * differentiating the highlighted row must not depend on a host
- * terminal correctly inverting fore/background, which a real mirasim
- * terminal session showed no visible effect from at all. The `>`/`  `
- * marker stays regardless, as a plain-text fallback for a host that
- * strips color entirely.
- */
-function highlightRow(text, isHighlighted) {
-    return isHighlighted ? `> ${ESC}[1;36m${text}${ESC}[0m` : `  ${text}`;
+    return wasCancelled(result, CANCEL_SYMBOL, isCancel) ? null : result;
 }
 /**
- * Single-select: Up/Down/j/k moves the highlight, Enter confirms. Resolves
- * the confirmed index, or `null` on Ctrl+C cancel. Caller (onboard.ts)
- * must have already confirmed `canUseInteractivePicker()` — this function
- * does not re-check, and assumes `streams.input` genuinely supports raw
- * mode.
+ * Checkbox prompt. The returned indices preserve the existing onboard
+ * contract, while Clack handles checked state, wrapping, colors, and cleanup.
  */
-export async function runSingleSelectPicker(items, streams = defaultStreams()) {
-    const { input, output } = streams;
-    return withRawMode(streams, () => {
-        return new Promise((resolve) => {
-            let highlighted = 0;
-            let physicalLines = 0;
-            const columns = columnsOf(output);
-            const draw = () => {
-                const rows = items.map((label, i) => highlightRow(label, i === highlighted));
-                renderRows(output, rows, physicalLines);
-                physicalLines = totalPhysicalLines(rows, columns);
-            };
-            draw();
-            const onData = (chunk) => {
-                const key = parseKey(chunk.toString("utf-8"));
-                if (key === "up") {
-                    highlighted = nextIndex(highlighted, -1, items.length);
-                    draw();
-                }
-                else if (key === "down") {
-                    highlighted = nextIndex(highlighted, 1, items.length);
-                    draw();
-                }
-                else if (key === "confirm") {
-                    input.removeListener("data", onData);
-                    resolve(highlighted);
-                }
-                else if (key === "cancel") {
-                    input.removeListener("data", onData);
-                    resolve(null);
-                }
-            };
-            input.on("data", onData);
-        });
+export async function runMultiSelectPicker(items, initiallyChecked, streams = defaultStreams(), message = "请选择要启用的项目") {
+    const { multiselect, CANCEL_SYMBOL, isCancel } = await clack();
+    const result = await multiselect({
+        message,
+        options: items.map((label, value) => ({ label, value })),
+        initialValues: items.flatMap((_, index) => (initiallyChecked[index] ? [index] : [])),
+        input: streams.input,
+        output: streams.output,
+        required: false,
+        showInstructions: true,
     });
-}
-/**
- * Multi-select (checkbox): Up/Down/j/k moves the highlight, Space toggles
- * the current row, Enter confirms. Resolves the checked indices at
- * confirm time, or `null` on Ctrl+C cancel. Same precondition as
- * `runSingleSelectPicker`.
- */
-export async function runMultiSelectPicker(items, initiallyChecked, streams = defaultStreams()) {
-    const { input, output } = streams;
-    return withRawMode(streams, () => {
-        return new Promise((resolve) => {
-            let highlighted = 0;
-            let checked = [...initiallyChecked];
-            let physicalLines = 0;
-            const columns = columnsOf(output);
-            const draw = () => {
-                const rows = items.map((label, i) => highlightRow(`[${checked[i] ? "x" : " "}] ${label}`, i === highlighted));
-                renderRows(output, rows, physicalLines);
-                physicalLines = totalPhysicalLines(rows, columns);
-            };
-            draw();
-            const onData = (chunk) => {
-                const key = parseKey(chunk.toString("utf-8"));
-                if (key === "up") {
-                    highlighted = nextIndex(highlighted, -1, items.length);
-                    draw();
-                }
-                else if (key === "down") {
-                    highlighted = nextIndex(highlighted, 1, items.length);
-                    draw();
-                }
-                else if (key === "toggle") {
-                    checked = toggled(checked, highlighted);
-                    draw();
-                }
-                else if (key === "confirm") {
-                    input.removeListener("data", onData);
-                    resolve(checked.flatMap((isChecked, i) => (isChecked ? [i] : [])));
-                }
-                else if (key === "cancel") {
-                    input.removeListener("data", onData);
-                    resolve(null);
-                }
-            };
-            input.on("data", onData);
-        });
+    return wasCancelled(result, CANCEL_SYMBOL, isCancel) ? null : [...result].sort((left, right) => left - right);
+}
+/** Searchable multiselect for large skill/MCP inventories. It returns the
+ * selected labels as stable names, preserving the semantic adapter contract
+ * while avoiding a wall of dozens of rows in the onboarding terminal. */
+export async function runSearchMultiSelectPicker(items, streams = defaultStreams(), message = "选择要迁移的项目") {
+    const { autocompleteMultiselect, CANCEL_SYMBOL, isCancel } = await clack();
+    const result = await autocompleteMultiselect({
+        message,
+        placeholder: "输入关键词筛选",
+        options: items.map((value) => ({ label: value, value })),
+        initialValues: [...items],
+        input: streams.input,
+        output: streams.output,
+        required: false,
     });
+    return wasCancelled(result, CANCEL_SYMBOL, isCancel) ? null : result;
 }

package/dist/lib/zcodeOwnership.d.ts

@@ -0,0 +1,17 @@
+/** Ownership record for the two ZCode native-Skill controls Trellis changes
+ * during strict Runtime delivery. MCP ownership stays in mcpOwnership.ts;
+ * this separate record lets a later native/both delivery restore the user's
+ * prior values without treating an ordinary config key as an MCP server. */
+export interface ZcodeSkillControlValues {
+    featuresSkill: boolean | null;
+    skillsEnabled: boolean | null;
+}
+export interface ZcodeSettingsOwnership {
+    configPath: string;
+    managed: ZcodeSkillControlValues;
+    previous: ZcodeSkillControlValues;
+}
+export declare function zcodeSettingsOwnershipPath(homeDir: string): string;
+export declare function loadZcodeSettingsOwnership(homeDir: string): ZcodeSettingsOwnership | undefined;
+export declare function saveZcodeSettingsOwnership(homeDir: string, value: ZcodeSettingsOwnership): void;
+export declare function forgetZcodeSettingsOwnership(homeDir: string): void;