agent-trellis 0.8.0 → 0.9.0

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/remoteSkill.d.ts

@@ -0,0 +1,90 @@
+/**
+ * `trellis add` and `trellis update`: GitHub-hosted Skill import with
+ * Trellis-owned canonical storage, provenance, scope, backup, and sync.
+ */
+import type { Scope } from "../core/types.js";
+import { type BackupSession } from "../lib/backup.js";
+import { type RemoteSkillLockEntry } from "../lib/remoteSkillLock.js";
+import { type FetchedRemoteRepository } from "../lib/remoteSkillSource.js";
+import type { SyncReport } from "./sync.js";
+export type RemoteSkillAction = "create" | "already-present" | "conflict" | "invalid-source" | "invalid-options";
+export interface RemoteSkillAddPlan {
+    name: string;
+    action: RemoteSkillAction;
+    detail: string;
+    source?: string;
+    requestedRef?: string;
+    commit?: string;
+    subdirectory?: string;
+    digest?: string;
+    canonicalPath?: string;
+    scope?: Scope;
+    /** Present only in process memory; never included in CLI output. */
+    sourceDir?: string;
+}
+export interface RemoteSkillAddOptions {
+    branch?: string;
+    agents?: readonly string[];
+    homeDir?: string;
+    dryRun?: boolean;
+    json?: boolean;
+}
+/** Builds an import plan from an already-fetched source.  Keeping fetching
+ * outside this function makes the real Git transport testable with a local
+ * bare repository while public CLI input remains GitHub-only. */
+export declare function collectRemoteSkillAddPlan(fetched: FetchedRemoteRepository, name: string | undefined, opts?: Omit<RemoteSkillAddOptions, "branch" | "dryRun" | "json">): RemoteSkillAddPlan;
+export interface RemoteSkillAddOutcome {
+    plan: Omit<RemoteSkillAddPlan, "sourceDir">;
+    sync?: SyncReport;
+}
+export declare function applyRemoteSkillAddPlan(plan: RemoteSkillAddPlan, opts?: {
+    homeDir?: string;
+    dryRun?: boolean;
+    backupSession?: BackupSession;
+}): Promise<RemoteSkillAddOutcome>;
+/** CLI-facing remote add.  The only source accepted here is normalized
+ * GitHub input; tests use collectRemoteSkillAddPlan with a local fetch. */
+export declare function runRemoteSkillAdd(sourceInput: string | undefined, name: string | undefined, opts?: RemoteSkillAddOptions): Promise<{
+    exitCode: number;
+}>;
+export declare function runRemoteSkillList(sourceInput: string | undefined, opts?: {
+    branch?: string;
+    json?: boolean;
+}): Promise<{
+    exitCode: number;
+}>;
+export type RemoteSkillUpdateAction = "already-current" | "update" | "conflict" | "not-tracked" | "invalid-source";
+export interface RemoteSkillUpdatePlan {
+    name: string;
+    action: RemoteSkillUpdateAction;
+    detail: string;
+    source?: string;
+    requestedRef?: string;
+    previousCommit?: string;
+    commit?: string;
+    previousDigest?: string;
+    digest?: string;
+    canonicalPath?: string;
+    sourceDir?: string;
+    replaceDirectory?: boolean;
+}
+export declare function collectRemoteSkillUpdatePlan(name: string, fetched: FetchedRemoteRepository | undefined, homeDir?: string): RemoteSkillUpdatePlan;
+export interface RemoteSkillUpdateOutcome {
+    plans: readonly Omit<RemoteSkillUpdatePlan, "sourceDir">[];
+    sync?: SyncReport;
+}
+export declare function applyRemoteSkillUpdatePlans(plans: readonly RemoteSkillUpdatePlan[], opts?: {
+    homeDir?: string;
+    dryRun?: boolean;
+    backupSession?: BackupSession;
+}): Promise<RemoteSkillUpdateOutcome>;
+export declare function runRemoteSkillUpdate(names: readonly string[], opts?: {
+    homeDir?: string;
+    dryRun?: boolean;
+    json?: boolean;
+}): Promise<{
+    exitCode: number;
+}>;
+/** Used by Skill listing to distinguish remote provenance from local content
+ * without making a malformed bookkeeping file crash a read-only list. */
+export declare function remoteSkillProvenance(homeDir: string): Record<string, RemoteSkillLockEntry>;