agent-trellis 0.8.0 → 0.8.2

package/dist/commands/init.js

@@ -16,6 +16,7 @@ import * as codexProbe from "../probes/codex.js";
 import * as kiroProbe from "../probes/kiro.js";
 import * as piProbe from "../probes/pi.js";
 import * as kimiCodeProbe from "../probes/kimi-code.js";
+import * as zcodeProbe from "../probes/zcode.js";
 import { ALL_AGENTS } from "../core/types.js";
 /** Exported so `migrate` can byte-compare canonical `agents.md` against
  * this exact string (design.md D3, trellis-cli-migrate) rather than
@@ -25,7 +26,7 @@ export const AGENTS_MD_TEMPLATE = `# Shared instructions
 Write what every agent should know here — communication preferences,
 project conventions, anything you'd otherwise repeat per agent.
 
-Already using Claude Code, Codex, Kiro, pi, or Kimi Code? \`trellis migrate --from
+Already using Claude Code, Codex, Kiro, pi, Kimi Code, or ZCode? \`trellis migrate --from
 <agent>\` imports its real instructions and skills instead of starting
 from this placeholder.
 `;
@@ -95,6 +96,7 @@ export const INSTALL_HINTS = {
     kiro: "https://kiro.dev/downloads/",
     pi: "npm install -g @earendil-works/pi-coding-agent",
     "kimi-code": "curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash",
+    zcode: "https://zcode.z.ai/en/docs/install",
 };
 function ensureFile(path, template, write = true) {
     if (existsSync(path)) {
@@ -132,6 +134,7 @@ export async function collectInitReport(homeDir = homedir(), options = {}) {
         { agent: "kiro", run: () => kiroProbe.probe(homeDir) },
         { agent: "pi", run: () => piProbe.probe(homeDir) },
         { agent: "kimi-code", run: () => kimiCodeProbe.probe(homeDir) },
+        { agent: "zcode", run: () => zcodeProbe.probe(homeDir) },
     ];
     const settled = await Promise.allSettled(probes.map((p) => p.run()));
     const agents = settled.map((result, index) => {

package/dist/commands/mcp.d.ts

@@ -5,10 +5,12 @@
  * gated — remove), and reports what happened. Kept as a separate
  * command from bare `trellis sync` (skills/instructions) since the two
  * have different write mechanisms entirely, not because MCP removal is
- * unsafe (see `src/lib/mcpOwnership.ts`). `list`/`add`/`remove`
- * (trellis-canonical-cli-crud) are canonical-side only — an alternative
- * to hand-editing `~/.trellis/mcp/servers.yaml`, never touching any
- * agent's native config (that stays `sync`'s job).
+ * unsafe (see `src/lib/mcpOwnership.ts`). `add`/`remove` mutate the
+ * canonical source and then run the same sync `mcp sync` performs, so
+ * one command both edits the list and maps it onto the managed agents
+ * (removal propagates through the ownership ledger). `list` is
+ * read-only. All three are an alternative to hand-editing
+ * `~/.trellis/mcp/servers.yaml`.
  */
 import { type ServersYamlWriteResult } from "../core/canonical.js";
 import type { AdapterPlanItem } from "../core/adapter.js";
@@ -128,29 +130,69 @@ export declare function runMcpSetAuth(name: string | undefined, auth: string | u
 }): {
     exitCode: number;
 };
-export declare function applyMcpAddPlan(plan: McpAddPlan, homeDir?: string): ServersYamlWriteResult;
+export declare function applyMcpAddPlan(plan: McpAddPlan, homeDir?: string, backup?: BackupSession): ServersYamlWriteResult;
+export interface McpAddOutcome {
+    plan: McpAddPlan;
+    writeError?: string;
+    sync?: McpSyncReport;
+}
+/**
+ * The apply-and-cascade-sync orchestration `runMcpAdd` used to do inline
+ * and only expose via a console.log'd payload — split out so a
+ * non-CLI caller (trellis-gui's sidecar) can get the same structured
+ * result a JSON-mode CLI run prints, without scraping stdout or
+ * re-deriving the same sequencing itself (trellis-gui design.md
+ * Decision 1). Behavior-preserving: `runMcpAdd` below is now a thin
+ * wrapper over this plus its own printing, same as every other command
+ * in this file already splits compute from CLI I/O.
+ *
+ * Opens its own backup session around the direct `servers.yaml` write
+ * when the caller doesn't already have one open — this canonical write
+ * used to be the one path in this file that bypassed backup/rollback
+ * entirely (trellis-gui tasks.md 3.5 found this empirically: a real `mcp
+ * add` left zero trace in `trellis rollback --list`). Mirrors the
+ * `ownSession` pattern `collectMcpSyncReport` below already uses for
+ * exactly the same reason.
+ */
+export declare function applyMcpAddWithSync(plan: McpAddPlan, opts?: {
+    homeDir?: string;
+    dryRun?: boolean;
+    backupSession?: BackupSession;
+}): Promise<McpAddOutcome>;
 export declare function runMcpAdd(name: string | undefined, raw: McpAddRawArgs, opts?: {
     homeDir?: string;
     json?: boolean;
     dryRun?: boolean;
-}): {
+}): Promise<{
     exitCode: number;
-};
+}>;
 export type McpRemoveAction = "removed" | "not-found";
 export interface McpRemovePlan {
     name: string;
     action: McpRemoveAction;
 }
-/** Canonical-side only — never touches an agent's native config. Making
- * an already-synced agent forget it is `mcp sync`'s own removal-
- * propagation gap, tracked separately (roadmap.md P14), not this
- * command's job. */
+/** Canonical plan only — `runMcpRemove` follows a real removal with the
+ * same sync `mcp sync` performs, which propagates the deletion to every
+ * agent whose entry the ownership ledger proves Trellis wrote
+ * (trellis-mcp-lifecycle-parity, roadmap P14). */
 export declare function collectMcpRemovePlan(name: string, homeDir?: string): McpRemovePlan;
-export declare function applyMcpRemovePlan(plan: McpRemovePlan, homeDir?: string): ServersYamlWriteResult;
+export declare function applyMcpRemovePlan(plan: McpRemovePlan, homeDir?: string, backup?: BackupSession): ServersYamlWriteResult;
+export interface McpRemoveOutcome {
+    plan: McpRemovePlan;
+    writeError?: string;
+    sync?: McpSyncReport;
+}
+/** See `applyMcpAddWithSync`'s doc comment — same split, same reason, same
+ * own-backup-session fix. */
+export declare function applyMcpRemoveWithSync(plan: McpRemovePlan, opts?: {
+    homeDir?: string;
+    dryRun?: boolean;
+    backupSession?: BackupSession;
+}): Promise<McpRemoveOutcome>;
 export declare function runMcpRemove(name: string, opts?: {
     homeDir?: string;
     json?: boolean;
     dryRun?: boolean;
-}): {
+}): Promise<{
     exitCode: number;
-};
+}>;

package/dist/commands/mcp.js

@@ -5,12 +5,15 @@
  * gated — remove), and reports what happened. Kept as a separate
  * command from bare `trellis sync` (skills/instructions) since the two
  * have different write mechanisms entirely, not because MCP removal is
- * unsafe (see `src/lib/mcpOwnership.ts`). `list`/`add`/`remove`
- * (trellis-canonical-cli-crud) are canonical-side only — an alternative
- * to hand-editing `~/.trellis/mcp/servers.yaml`, never touching any
- * agent's native config (that stays `sync`'s job).
+ * unsafe (see `src/lib/mcpOwnership.ts`). `add`/`remove` mutate the
+ * canonical source and then run the same sync `mcp sync` performs, so
+ * one command both edits the list and maps it onto the managed agents
+ * (removal propagates through the ownership ledger). `list` is
+ * read-only. All three are an alternative to hand-editing
+ * `~/.trellis/mcp/servers.yaml`.
  */
 import { homedir } from "node:os";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { loadCanonicalSource, upsertServerYaml, removeServerYaml } from "../core/canonical.js";
 import { ALL_AGENTS, resolveScope } from "../core/types.js";
@@ -19,6 +22,7 @@ import { CodexAdapter } from "../adapters/codex.js";
 import { KiroAdapter } from "../adapters/kiro.js";
 import { PiAdapter } from "../adapters/pi.js";
 import { KimiCodeAdapter } from "../adapters/kimi-code.js";
+import { ZcodeAdapter } from "../adapters/zcode.js";
 import { openBackupSession } from "../lib/backup.js";
 const ADAPTER_FACTORY = {
     "claude-code": (homeDir) => new ClaudeCodeAdapter(homeDir),
@@ -26,6 +30,7 @@ const ADAPTER_FACTORY = {
     kiro: (homeDir) => new KiroAdapter(homeDir),
     pi: (homeDir) => new PiAdapter(homeDir),
     "kimi-code": (homeDir) => new KimiCodeAdapter(homeDir),
+    zcode: (homeDir) => new ZcodeAdapter(homeDir),
 };
 /** Only agents in `canonical.managedAgents` — see src/commands/sync.ts's
  * own copy of this same restriction (trellis-managed-agents). */
@@ -297,12 +302,48 @@ export function runMcpSetAuth(name, auth, opts = {}) {
     }
     return { exitCode: ["invalid-input", "not-found"].includes(plan.action) || Boolean(writeError) ? 1 : 0 };
 }
-export function applyMcpAddPlan(plan, homeDir = homedir()) {
+export function applyMcpAddPlan(plan, homeDir = homedir(), backup) {
     if (plan.action !== "create" || !plan.def)
         return { ok: true };
-    return upsertServerYaml(serversYamlPath(homeDir), plan.name, plan.def);
+    return upsertServerYaml(serversYamlPath(homeDir), plan.name, plan.def, backup);
 }
-export function runMcpAdd(name, raw, opts = {}) {
+/**
+ * The apply-and-cascade-sync orchestration `runMcpAdd` used to do inline
+ * and only expose via a console.log'd payload — split out so a
+ * non-CLI caller (trellis-gui's sidecar) can get the same structured
+ * result a JSON-mode CLI run prints, without scraping stdout or
+ * re-deriving the same sequencing itself (trellis-gui design.md
+ * Decision 1). Behavior-preserving: `runMcpAdd` below is now a thin
+ * wrapper over this plus its own printing, same as every other command
+ * in this file already splits compute from CLI I/O.
+ *
+ * Opens its own backup session around the direct `servers.yaml` write
+ * when the caller doesn't already have one open — this canonical write
+ * used to be the one path in this file that bypassed backup/rollback
+ * entirely (trellis-gui tasks.md 3.5 found this empirically: a real `mcp
+ * add` left zero trace in `trellis rollback --list`). Mirrors the
+ * `ownSession` pattern `collectMcpSyncReport` below already uses for
+ * exactly the same reason.
+ */
+export async function applyMcpAddWithSync(plan, opts = {}) {
+    const homeDir = opts.homeDir ?? homedir();
+    const ownSession = !opts.dryRun && !opts.backupSession && plan.action === "create" ? openBackupSession(homeDir, "mcp-add") : undefined;
+    const session = opts.backupSession ?? ownSession;
+    let writeError;
+    if (!opts.dryRun && plan.action === "create") {
+        const result = applyMcpAddPlan(plan, homeDir, session);
+        if (!result.ok)
+            writeError = result.error;
+    }
+    ownSession?.finalize();
+    const planFailed = plan.action === "conflict" || plan.action === "invalid-input" || Boolean(writeError);
+    let syncReport;
+    if (!planFailed && plan.action === "create" && existsSync(join(homeDir, ".trellis"))) {
+        syncReport = await collectMcpSyncReport({ homeDir, dryRun: opts.dryRun });
+    }
+    return { plan, ...(writeError ? { writeError } : {}), ...(syncReport ? { sync: syncReport } : {}) };
+}
+export async function runMcpAdd(name, raw, opts = {}) {
     const homeDir = opts.homeDir ?? homedir();
     let plan;
     try {
@@ -312,37 +353,65 @@ export function runMcpAdd(name, raw, opts = {}) {
         console.error(err instanceof Error ? err.message : String(err));
         return { exitCode: 1 };
     }
-    let writeError;
-    if (!opts.dryRun && plan.action === "create") {
-        const result = applyMcpAddPlan(plan, homeDir);
-        if (!result.ok)
-            writeError = result.error;
+    let outcome;
+    try {
+        outcome = await applyMcpAddWithSync(plan, { homeDir, dryRun: opts.dryRun });
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return { exitCode: 1 };
     }
+    const { writeError, sync: syncReport } = outcome;
     if (opts.json) {
-        console.log(JSON.stringify(writeError ? { ...plan, writeError } : plan, null, 2));
+        const payload = writeError ? { ...plan, writeError } : plan;
+        console.log(JSON.stringify(syncReport ? { ...payload, sync: syncReport } : payload, null, 2));
     }
     else {
         console.log(`${opts.dryRun ? "[dry run] " : ""}mcp add ${plan.name}`);
         console.log(`  [${plan.action}] ${plan.detail}`);
         if (writeError)
             console.error(`  write failed: ${writeError}`);
+        if (syncReport)
+            printReport(syncReport, opts.dryRun ?? false);
     }
-    return { exitCode: plan.action === "conflict" || plan.action === "invalid-input" || writeError ? 1 : 0 };
+    const planFailed = plan.action === "conflict" || plan.action === "invalid-input" || Boolean(writeError);
+    const syncConflict = syncReport?.reports.some((r) => r.items.some((i) => i.action === "conflict")) ?? false;
+    return { exitCode: planFailed || syncConflict ? 1 : 0 };
 }
-/** Canonical-side only — never touches an agent's native config. Making
- * an already-synced agent forget it is `mcp sync`'s own removal-
- * propagation gap, tracked separately (roadmap.md P14), not this
- * command's job. */
+/** Canonical plan only — `runMcpRemove` follows a real removal with the
+ * same sync `mcp sync` performs, which propagates the deletion to every
+ * agent whose entry the ownership ledger proves Trellis wrote
+ * (trellis-mcp-lifecycle-parity, roadmap P14). */
 export function collectMcpRemovePlan(name, homeDir = homedir()) {
     const canonical = loadCanonicalSource(homeDir);
     return { name, action: canonical.mcp.servers[name] ? "removed" : "not-found" };
 }
-export function applyMcpRemovePlan(plan, homeDir = homedir()) {
+export function applyMcpRemovePlan(plan, homeDir = homedir(), backup) {
     if (plan.action !== "removed")
         return { ok: true };
-    return removeServerYaml(serversYamlPath(homeDir), plan.name);
+    return removeServerYaml(serversYamlPath(homeDir), plan.name, backup);
+}
+/** See `applyMcpAddWithSync`'s doc comment — same split, same reason, same
+ * own-backup-session fix. */
+export async function applyMcpRemoveWithSync(plan, opts = {}) {
+    const homeDir = opts.homeDir ?? homedir();
+    const ownSession = !opts.dryRun && !opts.backupSession && plan.action === "removed" ? openBackupSession(homeDir, "mcp-remove") : undefined;
+    const session = opts.backupSession ?? ownSession;
+    let writeError;
+    if (!opts.dryRun && plan.action === "removed") {
+        const result = applyMcpRemovePlan(plan, homeDir, session);
+        if (!result.ok)
+            writeError = result.error;
+    }
+    ownSession?.finalize();
+    const planFailed = plan.action === "not-found" || Boolean(writeError);
+    let syncReport;
+    if (!planFailed && existsSync(join(homeDir, ".trellis"))) {
+        syncReport = await collectMcpSyncReport({ homeDir, dryRun: opts.dryRun });
+    }
+    return { plan, ...(writeError ? { writeError } : {}), ...(syncReport ? { sync: syncReport } : {}) };
 }
-export function runMcpRemove(name, opts = {}) {
+export async function runMcpRemove(name, opts = {}) {
     const homeDir = opts.homeDir ?? homedir();
     let plan;
     try {
@@ -352,14 +421,19 @@ export function runMcpRemove(name, opts = {}) {
         console.error(err instanceof Error ? err.message : String(err));
         return { exitCode: 1 };
     }
-    let writeError;
-    if (!opts.dryRun && plan.action === "removed") {
-        const result = applyMcpRemovePlan(plan, homeDir);
-        if (!result.ok)
-            writeError = result.error;
+    let outcome;
+    try {
+        outcome = await applyMcpRemoveWithSync(plan, { homeDir, dryRun: opts.dryRun });
     }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return { exitCode: 1 };
+    }
+    const { writeError, sync: syncReport } = outcome;
+    const planFailed = plan.action === "not-found" || Boolean(writeError);
     if (opts.json) {
-        console.log(JSON.stringify(writeError ? { ...plan, writeError } : plan, null, 2));
+        const payload = writeError ? { ...plan, writeError } : plan;
+        console.log(JSON.stringify(syncReport ? { ...payload, sync: syncReport } : payload, null, 2));
     }
     else if (plan.action === "not-found") {
         console.error(`"${name}" is not a canonical MCP server — nothing to remove.`);
@@ -369,6 +443,9 @@ export function runMcpRemove(name, opts = {}) {
     }
     else {
         console.log(`${opts.dryRun ? "[dry run] " : ""}removed MCP server "${name}" from canonical source.`);
+        if (syncReport)
+            printReport(syncReport, opts.dryRun ?? false);
     }
-    return { exitCode: plan.action === "not-found" || writeError ? 1 : 0 };
+    const syncConflict = syncReport?.reports.some((r) => r.items.some((i) => i.action === "conflict")) ?? false;
+    return { exitCode: planFailed || syncConflict ? 1 : 0 };
 }

package/dist/commands/mcpGateway.js

@@ -24,6 +24,7 @@ import { BuiltinRegistry, createRuntimeServer, UpstreamProvider } from "../lib/m
 import { McpStatusProvider } from "../lib/mcpStatusProvider.js";
 import { RuntimeControlProvider } from "../lib/runtimeControlProvider.js";
 import { TaskProvider } from "../lib/taskProvider.js";
+import { AgentBridgeProvider } from "../lib/agentBridgeProvider.js";
 import { RuntimeMemoryProvider } from "../lib/memoryProvider.js";
 import { SkillProvider } from "../lib/skillProvider.js";
 import { ALL_AGENTS } from "../core/types.js";
@@ -121,7 +122,7 @@ async function runMcpEdge(opts, clientInfo, serverInfo) {
             // process has no terminal to run one in (design.md D9).
             homeDir,
         });
-    const registry = new BuiltinRegistry([new SkillProvider(), new RuntimeMemoryProvider(), new RuntimeControlProvider(backend), new McpStatusProvider(backend), new TaskProvider(), new UpstreamProvider(backend)]);
+    const registry = new BuiltinRegistry([new SkillProvider(), new RuntimeMemoryProvider(), new RuntimeControlProvider(backend), new McpStatusProvider(backend), new TaskProvider(), new AgentBridgeProvider(), new UpstreamProvider(backend)]);
     const server = createRuntimeServer(serverInfo, { agentId: opts.agentId, homeDir }, registry);
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/commands/mcpImport.d.ts

@@ -6,6 +6,7 @@
  * read-only; plans never carry secret values.
  */
 import { type BackupSession } from "../lib/backup.js";
+import type { McpSyncReport } from "./mcp.js";
 export type McpImportAction = "create" | "already-present" | "duplicate" | "skipped" | "conflict" | "invalid-input";
 export interface McpImportItem {
     name: string;
@@ -18,10 +19,28 @@ export interface McpImportPlan {
 }
 export declare function collectMcpImportPlan(path: string, homeDir?: string): McpImportPlan;
 export declare function applyMcpImportPlan(path: string, homeDir?: string, backup?: BackupSession): McpImportPlan;
+export interface McpImportOutcome {
+    plan: McpImportPlan;
+    sync?: McpSyncReport;
+}
+/**
+ * See `applyMcpAddWithSync`'s doc comment (mcp.ts) — same split, same
+ * reason: a non-CLI caller (trellis-gui's sidecar) gets the same
+ * structured result a JSON-mode CLI run prints, without scraping
+ * stdout or re-deriving the plan-then-apply-then-cascade-sync
+ * sequencing itself. Unlike `mcp add`/`mcp remove`, `applyMcpImportPlan`
+ * already opens its own backup session unconditionally (it always has,
+ * per design.md's original survey of `openBackupSession` call sites) —
+ * no tasks.md 3.5-style fix needed here.
+ */
+export declare function applyMcpImportWithSync(path: string, opts?: {
+    homeDir?: string;
+    dryRun?: boolean;
+}): Promise<McpImportOutcome>;
 export declare function runMcpImport(path: string | undefined, opts?: {
     homeDir?: string;
     json?: boolean;
     dryRun?: boolean;
-}): {
+}): Promise<{
     exitCode: number;
-};
+}>;

package/dist/commands/mcpImport.js

@@ -11,6 +11,7 @@ import { join } from "node:path";
 import { loadCanonicalSource, ensureGitignoreEntry, ensureShellEnvSource, upsertServerYaml, writeSecretsPolicyExtraction } from "../core/canonical.js";
 import { openBackupSession } from "../lib/backup.js";
 import { parseDotenv, writeLocalSecretValue } from "../lib/secretEnv.js";
+import { collectMcpSyncReport, printReport as printMcpSyncReport } from "./mcp.js";
 const DEFAULT_ENV_FILE_TILDE = "~/.trellis/mcp/servers.local.env";
 class SkipImport extends Error {
 }
@@ -309,25 +310,47 @@ export function applyMcpImportPlan(path, homeDir = homedir(), backup) {
         ownSession.finalize();
     return publicPlan(plan);
 }
-export function runMcpImport(path, opts = {}) {
+/**
+ * See `applyMcpAddWithSync`'s doc comment (mcp.ts) — same split, same
+ * reason: a non-CLI caller (trellis-gui's sidecar) gets the same
+ * structured result a JSON-mode CLI run prints, without scraping
+ * stdout or re-deriving the plan-then-apply-then-cascade-sync
+ * sequencing itself. Unlike `mcp add`/`mcp remove`, `applyMcpImportPlan`
+ * already opens its own backup session unconditionally (it always has,
+ * per design.md's original survey of `openBackupSession` call sites) —
+ * no tasks.md 3.5-style fix needed here.
+ */
+export async function applyMcpImportWithSync(path, opts = {}) {
+    const homeDir = opts.homeDir ?? homedir();
+    const plan = opts.dryRun ? collectMcpImportPlan(path, homeDir) : applyMcpImportPlan(path, homeDir);
+    const failed = plan.items.some((item) => item.action === "conflict" || item.action === "invalid-input");
+    const changed = plan.items.some((item) => item.action === "create");
+    let syncReport;
+    if (!failed && changed && existsSync(join(homeDir, ".trellis"))) {
+        syncReport = await collectMcpSyncReport({ homeDir, dryRun: opts.dryRun });
+    }
+    return { plan, ...(syncReport ? { sync: syncReport } : {}) };
+}
+export async function runMcpImport(path, opts = {}) {
     const homeDir = opts.homeDir ?? homedir();
     if (!path) {
         console.error("Usage: trellis mcp import <json-file> [--dry-run]");
         return { exitCode: 1 };
     }
     try {
-        const internal = collectInternalPlan(path, homeDir);
-        if (!opts.dryRun)
-            applyMcpImportPlan(path, homeDir);
-        const result = publicPlan(internal);
+        const { plan: result, sync: syncReport } = await applyMcpImportWithSync(path, { homeDir, dryRun: opts.dryRun });
+        const failed = result.items.some((item) => item.action === "conflict" || item.action === "invalid-input");
         if (opts.json)
-            console.log(JSON.stringify(result, null, 2));
+            console.log(JSON.stringify(syncReport ? { ...result, sync: syncReport } : result, null, 2));
         else {
             console.log(`${opts.dryRun ? "[dry run] " : ""}mcp import ${path}`);
             for (const item of result.items)
                 console.log(`  [${item.action}] ${item.name} — ${item.detail}`);
+            if (syncReport)
+                printMcpSyncReport(syncReport, opts.dryRun ?? false);
         }
-        return { exitCode: result.items.some((item) => item.action === "conflict" || item.action === "invalid-input") ? 1 : 0 };
+        const syncConflict = syncReport?.reports.some((r) => r.items.some((i) => i.action === "conflict")) ?? false;
+        return { exitCode: failed || syncConflict ? 1 : 0 };
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));

package/dist/commands/memory.d.ts

@@ -12,9 +12,21 @@
  * server process — both are plain file operations, same posture as
  * every other Trellis write.
  */
-import type { McpConfig, McpServerDef } from "../core/types.js";
+import type { AgentId, McpConfig, McpServerDef } from "../core/types.js";
 import type { BackupSession } from "../lib/backup.js";
 import { type MemoryExtractionPlan, type MemorySyncPlan } from "../lib/memoryGraph.js";
+export interface MemoryListEntry {
+    name: string;
+    scope: readonly AgentId[];
+}
+/** Canonical `memories/*.md` profile files — the list `trellis-gui`'s
+ * Memory view reads (tasks.md 6.2), mirroring `collectSkillList`'s
+ * shape exactly (skill.ts) since both are "canonical files with a
+ * resolved managed-agent scope" lists. Distinct from this file's own
+ * `MEMORY_SERVER_NAME` sync/extraction pipeline below, which is about
+ * the separate shared-Memory-MCP-server knowledge graph, not these
+ * per-topic markdown files. */
+export declare function collectMemoryList(homeDir?: string): MemoryListEntry[];
 /** Exported so `onboard` (`trellis onboard --memory on|off`,
  * trellis-onboard-mcp-mode) can look up and write this same entry
  * without hardcoding the name a second time. */

package/dist/commands/memory.js

@@ -16,7 +16,22 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { loadCanonicalSource } from "../core/canonical.js";
+import { resolveScope } from "../core/types.js";
 import { parseMemoryGraph, planMemoryExtraction, planMemorySync, renderMemoryGraph } from "../lib/memoryGraph.js";
+/** Canonical `memories/*.md` profile files — the list `trellis-gui`'s
+ * Memory view reads (tasks.md 6.2), mirroring `collectSkillList`'s
+ * shape exactly (skill.ts) since both are "canonical files with a
+ * resolved managed-agent scope" lists. Distinct from this file's own
+ * `MEMORY_SERVER_NAME` sync/extraction pipeline below, which is about
+ * the separate shared-Memory-MCP-server knowledge graph, not these
+ * per-topic markdown files. */
+export function collectMemoryList(homeDir = homedir()) {
+    const canonical = loadCanonicalSource(homeDir);
+    return canonical.memories.map((memory) => ({
+        name: memory.name,
+        scope: resolveScope(memory.scope, canonical.managedAgents),
+    }));
+}
 /** Exported so `onboard` (`trellis onboard --memory on|off`,
  * trellis-onboard-mcp-mode) can look up and write this same entry
  * without hardcoding the name a second time. */

package/dist/commands/migrate.js

@@ -12,10 +12,11 @@ import * as codexProbe from "../probes/codex.js";
 import * as kiroProbe from "../probes/kiro.js";
 import * as piProbe from "../probes/pi.js";
 import * as kimiCodeProbe from "../probes/kimi-code.js";
+import * as zcodeProbe from "../probes/zcode.js";
 import { AGENTS_MD_TEMPLATE } from "./init.js";
 import { decideDirImport } from "../lib/dirEquals.js";
 import { deepEqual } from "../lib/deepEqual.js";
-import { readClaudeCodeMcpDefs, readCodexMcpDefs, readKiroMcpDefs, readKimiCodeMcpDefs, resolvedEnvTextMap } from "../lib/mcpMigrateRead.js";
+import { readClaudeCodeMcpDefs, readCodexMcpDefs, readKiroMcpDefs, readKimiCodeMcpDefs, readZcodeMcpDefs, resolvedEnvTextMap } from "../lib/mcpMigrateRead.js";
 import { parseDotenv, writeLocalSecretValue } from "../lib/secretEnv.js";
 import { findLiteralSecret } from "../adapters/mcpPlan.js";
 import { ensureGitignoreEntry, ensureShellEnvSource, loadCanonicalSource, upsertServerYaml, writeSecretsPolicyExtraction } from "../core/canonical.js";
@@ -51,6 +52,7 @@ const PROBES = {
     kiro: (homeDir) => kiroProbe.probe(homeDir),
     pi: (homeDir) => piProbe.probe(homeDir),
     "kimi-code": (homeDir) => kimiCodeProbe.probe(homeDir),
+    zcode: (homeDir) => zcodeProbe.probe(homeDir),
 };
 /** pi has no static MCP config to read at all (roadmap.md P14/
  * trellis-migrate-mcp-servers) — deliberately absent, not an oversight;
@@ -60,6 +62,7 @@ const MCP_READERS = {
     kiro: readKiroMcpDefs,
     codex: readCodexMcpDefs,
     "kimi-code": readKimiCodeMcpDefs,
+    zcode: readZcodeMcpDefs,
 };
 function planSkill(name, sourceDir, isSymlink, caseCorrect, canonicalDir) {
     if (isSymlink) {

package/dist/commands/onboard.js

@@ -23,6 +23,7 @@ import * as codexProbe from "../probes/codex.js";
 import * as kiroProbe from "../probes/kiro.js";
 import * as piProbe from "../probes/pi.js";
 import * as kimiCodeProbe from "../probes/kimi-code.js";
+import * as zcodeProbe from "../probes/zcode.js";
 import { ALL_AGENTS, capabilityDeliveryForAgent } from "../core/types.js";
 import { loadCanonicalSource, removeServerYaml, upsertServerYaml, writeMcpModeYaml, writeMcpRoutesYaml, writeMcpRuntimeDeliveryYaml } from "../core/canonical.js";
 import { buildCapabilityInventory, parseCapabilitySelectionFile, resolveSelectedNames, selectionContains } from "../core/capabilitySelection.js";
@@ -47,6 +48,7 @@ const PROBES = {
     kiro: (homeDir) => kiroProbe.probe(homeDir),
     pi: (homeDir) => piProbe.probe(homeDir),
     "kimi-code": (homeDir) => kimiCodeProbe.probe(homeDir),
+    zcode: (homeDir) => zcodeProbe.probe(homeDir),
 };
 /**
  * Scores only real source-side content. The recommendation is a hint for a
@@ -824,14 +826,23 @@ export async function collectOnboardPlan(opts = {}) {
     if (!requestedRoutes && shouldPromptForRoutes) {
         requestedRoutes = await resolveInteractiveMcpRoutes(managedAgents, availableMcpNames, currentMcpAfterMigration.hub !== undefined);
     }
-    const requestedRuntimeDelivery = capabilitySelection?.runtimeDelivery;
+    // ZCode's generic ~/.agents/skills discovery bypasses Trellis scope. Its
+    // default is therefore Runtime-first unless a capability-selection file
+    // explicitly chooses native/both, or canonical already has a choice.
+    const zcodeRuntimeRecommendation = managedAgents.includes("zcode") && currentMcpAfterMigration.runtime?.delivery?.zcode === undefined
+        ? { zcode: "mcp" }
+        : {};
+    const requestedRuntimeDelivery = {
+        ...zcodeRuntimeRecommendation,
+        ...(capabilitySelection?.runtimeDelivery ?? {}),
+    };
     let mcpSyncOverride;
-    if ((requestedRoutes && Object.keys(requestedRoutes).length > 0) || (requestedRuntimeDelivery && Object.keys(requestedRuntimeDelivery).length > 0)) {
+    if ((requestedRoutes && Object.keys(requestedRoutes).length > 0) || Object.keys(requestedRuntimeDelivery).length > 0) {
         const currentMcp = currentMcpAfterMigration;
         const routes = requestedRoutes && Object.keys(requestedRoutes).length > 0
             ? { ...(currentMcp.routes ?? {}), ...requestedRoutes }
             : currentMcp.routes;
-        const delivery = requestedRuntimeDelivery && Object.keys(requestedRuntimeDelivery).length > 0
+        const delivery = Object.keys(requestedRuntimeDelivery).length > 0
             ? { ...(currentMcp.runtime?.delivery ?? {}), ...requestedRuntimeDelivery }
             : currentMcp.runtime?.delivery;
         mcpSyncOverride = {
@@ -842,7 +853,7 @@ export async function collectOnboardPlan(opts = {}) {
         if (!opts.dryRun && requestedRoutes && Object.keys(requestedRoutes).length > 0) {
             writeMcpRoutesYaml(join(homeDir, ".trellis", "mcp", "servers.yaml"), routes ?? {}, backupSession);
         }
-        if (!opts.dryRun && requestedRuntimeDelivery && Object.keys(requestedRuntimeDelivery).length > 0) {
+        if (!opts.dryRun && Object.keys(requestedRuntimeDelivery).length > 0) {
             writeMcpRuntimeDeliveryYaml(join(homeDir, ".trellis", "mcp", "servers.yaml"), delivery ?? {}, backupSession);
         }
     }

package/dist/commands/rollback.js

@@ -8,7 +8,7 @@
  * already hold themselves to for every other kind of conflict.
  */
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { cpSync, existsSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { readlink, rm, symlink } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -99,6 +99,23 @@ async function planOperation(homeDir, runId, op) {
             }
             return { action: "restore", path: op.path, description: `recreate ${op.path} -> ${op.beforeLinkTarget}` };
         }
+        // Directory conflict detection is existence-only, not a deep content
+        // hash (see BackupOperation's "dir-create"/"dir-remove" doc comment
+        // in backup.ts) — a real, documented simplification, not an
+        // oversight: something touching a file inside an otherwise-untouched
+        // directory won't be caught as a conflict.
+        case "dir-create": {
+            if (!existsSync(op.path)) {
+                return { action: "already-reverted", path: op.path, description: `${op.path} no longer exists — nothing to undo` };
+            }
+            return { action: "restore", path: op.path, description: `delete ${op.path} (created by this run)` };
+        }
+        case "dir-remove": {
+            if (existsSync(op.path)) {
+                return { action: "conflict", path: op.path, description: `${op.path} exists again since this run — left untouched` };
+            }
+            return { action: "restore", path: op.path, description: `recreate ${op.path} from its content before this run (${join(runDir, op.beforeDir)})` };
+        }
     }
 }
 export async function collectRollbackPlan(homeDirInput, runIdInput) {
@@ -130,6 +147,12 @@ async function restoreOperation(homeDir, runId, op) {
         case "symlink-remove":
             await symlink(op.beforeLinkTarget, op.path);
             return;
+        case "dir-create":
+            rmSync(op.path, { recursive: true, force: true });
+            return;
+        case "dir-remove":
+            cpSync(join(runDir, op.beforeDir), op.path, { recursive: true });
+            return;
     }
 }
 export async function applyRollbackPlan(homeDir, runId, manifest, items) {