gsd-pi 2.23.0 → 2.25.0

package/README.md

@@ -36,7 +36,8 @@ Full documentation is available in the [`docs/`](./docs/) directory:
 - **[Skills](./docs/skills.md)** — bundled skills, discovery, custom authoring
 - **[Commands Reference](./docs/commands.md)** — all commands and keyboard shortcuts
 - **[Architecture](./docs/architecture.md)** — system design and dispatch pipeline
-- **[Troubleshooting](./docs/troubleshooting.md)** — common issues, doctor, recovery
+- **[Troubleshooting](./docs/troubleshooting.md)** — common issues, doctor, forensics, recovery
+- **[VS Code Extension](./vscode-extension/README.md)** — chat participant, sidebar dashboard, RPC integration
 - **[Migration from v1](./docs/migration.md)** — `.planning` → `.gsd` migration
 
 ---

package/dist/cli.js

@@ -8,7 +8,7 @@ import { loadStoredEnvKeys } from './wizard.js';
 import { getPiDefaultModelAndProvider, migratePiCredentials } from './pi-migration.js';
 import { shouldRunOnboarding, runOnboarding } from './onboarding.js';
 import chalk from 'chalk';
-import { checkForUpdates } from './update-check.js';
+import { checkForUpdates, checkAndPromptForUpdates } from './update-check.js';
 import { printHelp, printSubcommandHelp } from './help-text.js';
 function exitIfManagedResourcesAreNewer(currentAgentDir) {
     const currentVersion = process.env.GSD_VERSION || '0.0.0';
@@ -169,9 +169,18 @@ if (!isPrintMode && shouldRunOnboarding(authStorage, settingsManager.getDefaultP
         process.stdin.setRawMode(false);
     process.stdin.pause();
 }
-// Non-blocking update check — runs at most once per 24h, fire-and-forget
+// Update check — interactive prompt when stdin is a TTY, passive banner otherwise
 if (!isPrintMode) {
-    checkForUpdates().catch(() => { });
+    if (process.stdin.isTTY) {
+        const updated = await checkAndPromptForUpdates().catch(() => false);
+        if (updated) {
+            // User chose to update — exit so they relaunch with the new version
+            process.exit(0);
+        }
+    }
+    else {
+        checkForUpdates().catch(() => { });
+    }
 }
 // Warn if terminal is too narrow for readable output
 if (!isPrintMode && process.stdout.columns && process.stdout.columns < 40) {

package/dist/headless.d.ts

@@ -16,6 +16,10 @@ export interface HeadlessOptions {
     model?: string;
     command: string;
     commandArgs: string[];
+    context?: string;
+    contextText?: string;
+    auto?: boolean;
+    verbose?: boolean;
 }
 export declare function parseHeadlessArgs(argv: string[]): HeadlessOptions;
 export declare function runHeadless(options: HeadlessOptions): Promise<void>;

package/dist/headless.js

@@ -10,8 +10,8 @@
  *   1 — error or timeout
  *   2 — blocked (command reported a blocker)
  */
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 // RpcClient is not in @gsd/pi-coding-agent's public exports — import from dist directly.
 // This relative path resolves correctly from both src/ (via tsx) and dist/ (compiled).
 import { RpcClient } from '../packages/pi-coding-agent/dist/modes/rpc/rpc-client.js';
@@ -46,6 +46,18 @@ export function parseHeadlessArgs(argv) {
                 // --model can also be passed from the main CLI; headless-specific takes precedence
                 options.model = args[++i];
             }
+            else if (arg === '--context' && i + 1 < args.length) {
+                options.context = args[++i];
+            }
+            else if (arg === '--context-text' && i + 1 < args.length) {
+                options.contextText = args[++i];
+            }
+            else if (arg === '--auto') {
+                options.auto = true;
+            }
+            else if (arg === '--verbose') {
+                options.verbose = true;
+            }
         }
         else if (!positionalStarted) {
             positionalStarted = true;
@@ -99,18 +111,23 @@ function handleExtensionUIRequest(event, writeToStdin) {
 // ---------------------------------------------------------------------------
 // Progress Formatter
 // ---------------------------------------------------------------------------
-function formatProgress(event) {
+function formatProgress(event, verbose) {
     const type = String(event.type ?? '');
     switch (type) {
         case 'tool_execution_start':
-            return `[tool] ${event.toolName ?? 'unknown'}`;
+            if (verbose)
+                return `  [tool]    ${event.toolName ?? 'unknown'}`;
+            return null;
         case 'agent_start':
-            return '[agent] Session started';
+            return '[agent]   Session started';
         case 'agent_end':
-            return '[agent] Session ended';
+            return '[agent]   Session ended';
         case 'extension_ui_request':
             if (event.method === 'notify') {
-                return `[gsd] ${event.message ?? ''}`;
+                return `[gsd]     ${event.message ?? ''}`;
+            }
+            if (event.method === 'setStatus') {
+                return `[status]  ${event.message ?? ''}`;
             }
             return null;
         default:
@@ -133,6 +150,11 @@ function isBlockedNotification(event) {
         return false;
     return String(event.message ?? '').toLowerCase().includes('blocked');
 }
+function isMilestoneReadyNotification(event) {
+    if (event.type !== 'extension_ui_request' || event.method !== 'notify')
+        return false;
+    return /milestone\s+m\d+.*ready/i.test(String(event.message ?? ''));
+}
 // ---------------------------------------------------------------------------
 // Quick Command Detection
 // ---------------------------------------------------------------------------
@@ -148,11 +170,69 @@ function isQuickCommand(command) {
 // ---------------------------------------------------------------------------
 // Main Orchestrator
 // ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Context Loading (new-milestone)
+// ---------------------------------------------------------------------------
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf-8');
+}
+async function loadContext(options) {
+    if (options.contextText)
+        return options.contextText;
+    if (options.context === '-') {
+        return readStdin();
+    }
+    if (options.context) {
+        return readFileSync(resolve(options.context), 'utf-8');
+    }
+    throw new Error('No context provided. Use --context <file> or --context-text <text>');
+}
+/**
+ * Bootstrap .gsd/ directory structure for headless new-milestone.
+ * Mirrors the bootstrap logic from guided-flow.ts showSmartEntry().
+ */
+function bootstrapGsdProject(basePath) {
+    const gsdDir = join(basePath, '.gsd');
+    mkdirSync(join(gsdDir, 'milestones'), { recursive: true });
+    mkdirSync(join(gsdDir, 'runtime'), { recursive: true });
+}
 export async function runHeadless(options) {
     const startTime = Date.now();
-    // Validate .gsd/ directory
+    const isNewMilestone = options.command === 'new-milestone';
+    // For new-milestone, load context and bootstrap .gsd/ before spawning RPC child
+    if (isNewMilestone) {
+        if (!options.context && !options.contextText) {
+            process.stderr.write('[headless] Error: new-milestone requires --context <file> or --context-text <text>\n');
+            process.exit(1);
+        }
+        let contextContent;
+        try {
+            contextContent = await loadContext(options);
+        }
+        catch (err) {
+            process.stderr.write(`[headless] Error loading context: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+        // Bootstrap .gsd/ if needed
+        const gsdDir = join(process.cwd(), '.gsd');
+        if (!existsSync(gsdDir)) {
+            if (!options.json) {
+                process.stderr.write('[headless] Bootstrapping .gsd/ project structure...\n');
+            }
+            bootstrapGsdProject(process.cwd());
+        }
+        // Write context to temp file for the RPC child to read
+        const runtimeDir = join(gsdDir, 'runtime');
+        mkdirSync(runtimeDir, { recursive: true });
+        writeFileSync(join(runtimeDir, 'headless-context.md'), contextContent, 'utf-8');
+    }
+    // Validate .gsd/ directory (skip for new-milestone since we just bootstrapped it)
     const gsdDir = join(process.cwd(), '.gsd');
-    if (!existsSync(gsdDir)) {
+    if (!isNewMilestone && !existsSync(gsdDir)) {
         process.stderr.write('[headless] Error: No .gsd/ directory found in current directory.\n');
         process.stderr.write("[headless] Run 'gsd' interactively first to initialize a project.\n");
         process.exit(1);
@@ -178,6 +258,7 @@ export async function runHeadless(options) {
     let blocked = false;
     let completed = false;
     let exitCode = 0;
+    let milestoneReady = false; // tracks "Milestone X ready." for auto-chaining
     const recentEvents = [];
     function trackEvent(event) {
         totalEvents++;
@@ -231,7 +312,7 @@ export async function runHeadless(options) {
         }
         else {
             // Progress output to stderr
-            const line = formatProgress(eventObj);
+            const line = formatProgress(eventObj, !!options.verbose);
             if (line)
                 process.stderr.write(line + '\n');
         }
@@ -241,6 +322,10 @@ export async function runHeadless(options) {
             if (isBlockedNotification(eventObj)) {
                 blocked = true;
             }
+            // Detect "Milestone X ready." for auto-mode chaining
+            if (isMilestoneReadyNotification(eventObj)) {
+                milestoneReady = true;
+            }
             if (isTerminalNotification(eventObj)) {
                 completed = true;
             }
@@ -319,6 +404,29 @@ export async function runHeadless(options) {
     if (exitCode === 0 || exitCode === 2) {
         await completionPromise;
     }
+    // Auto-mode chaining: if --auto and milestone creation succeeded, send /gsd auto
+    if (isNewMilestone && options.auto && milestoneReady && !blocked && exitCode === 0) {
+        if (!options.json) {
+            process.stderr.write('[headless] Milestone ready — chaining into auto-mode...\n');
+        }
+        // Reset completion state for the auto-mode phase
+        completed = false;
+        milestoneReady = false;
+        blocked = false;
+        const autoCompletionPromise = new Promise((resolve) => {
+            resolveCompletion = resolve;
+        });
+        try {
+            await client.prompt('/gsd auto');
+        }
+        catch (err) {
+            process.stderr.write(`[headless] Error: Failed to start auto-mode: ${err instanceof Error ? err.message : String(err)}\n`);
+            exitCode = 1;
+        }
+        if (exitCode === 0 || exitCode === 2) {
+            await autoCompletionPromise;
+        }
+    }
     // Cleanup
     clearTimeout(timeoutTimer);
     if (idleTimer)

package/dist/help-text.js

@@ -35,15 +35,30 @@ const SUBCOMMAND_HELP = {
         'Run /gsd commands without the TUI. Default command: auto',
         '',
         'Flags:',
-        '  --timeout N     Overall timeout in ms (default: 300000)',
-        '  --json          JSONL event stream to stdout',
-        '  --model ID      Override model',
+        '  --timeout N          Overall timeout in ms (default: 300000)',
+        '  --json               JSONL event stream to stdout',
+        '  --model ID           Override model',
+        '',
+        'Commands:',
+        '  auto                 Run all queued units continuously (default)',
+        '  next                 Run one unit',
+        '  status               Show progress dashboard',
+        '  new-milestone        Create a milestone from a specification document',
+        '',
+        'new-milestone flags:',
+        '  --context <path>     Path to spec/PRD file (use \'-\' for stdin)',
+        '  --context-text <txt> Inline specification text',
+        '  --auto               Start auto-mode after milestone creation',
+        '  --verbose            Show tool calls in progress output',
         '',
         'Examples:',
-        '  gsd headless                    Run /gsd auto',
-        '  gsd headless next               Run one unit',
-        '  gsd headless --json status      Machine-readable status',
-        '  gsd headless --timeout 60000    With 1-minute timeout',
+        '  gsd headless                                    Run /gsd auto',
+        '  gsd headless next                               Run one unit',
+        '  gsd headless --json status                      Machine-readable status',
+        '  gsd headless --timeout 60000                    With 1-minute timeout',
+        '  gsd headless new-milestone --context spec.md    Create milestone from file',
+        '  cat spec.md | gsd headless new-milestone --context -   From stdin',
+        '  gsd headless new-milestone --context spec.md --auto    Create + auto-execute',
         '',
         'Exit codes: 0 = complete, 1 = error/timeout, 2 = blocked',
     ].join('\n'),

package/dist/models-resolver.d.ts

@@ -19,14 +19,3 @@
  * @returns The path to use for models.json
  */
 export declare function resolveModelsJsonPath(): string;
-/**
- * Check if both GSD and PI models.json files exist.
- */
-export declare function hasBothModelsFiles(): boolean;
-/**
- * Get the paths to both models.json files.
- */
-export declare function getModelsPaths(): {
-    gsd: string;
-    pi: string;
-};

package/dist/models-resolver.js

@@ -33,18 +33,3 @@ export function resolveModelsJsonPath() {
     }
     return GSD_MODELS_PATH;
 }
-/**
- * Check if both GSD and PI models.json files exist.
- */
-export function hasBothModelsFiles() {
-    return existsSync(GSD_MODELS_PATH) && existsSync(PI_MODELS_PATH);
-}
-/**
- * Get the paths to both models.json files.
- */
-export function getModelsPaths() {
-    return {
-        gsd: GSD_MODELS_PATH,
-        pi: PI_MODELS_PATH,
-    };
-}

package/dist/resource-loader.d.ts

@@ -1,7 +1,6 @@
 import { DefaultResourceLoader } from '@gsd/pi-coding-agent';
 export declare function discoverExtensionEntryPaths(extensionsDir: string): string[];
 export declare function readManagedResourceVersion(agentDir: string): string | null;
-export declare function readManagedResourceSyncedAt(agentDir: string): number | null;
 export declare function getNewerManagedResourceVersion(agentDir: string, currentVersion: string): string | null;
 /**
  * Syncs all bundled resources to agentDir (~/.gsd/agent/) on every launch.

package/dist/resource-loader.js

@@ -1,6 +1,6 @@
 import { DefaultResourceLoader } from '@gsd/pi-coding-agent';
 import { homedir } from 'node:os';
-import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { chmodSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { compareSemver } from './update-check.js';
@@ -97,15 +97,6 @@ export function readManagedResourceVersion(agentDir) {
         return null;
     }
 }
-export function readManagedResourceSyncedAt(agentDir) {
-    try {
-        const manifest = JSON.parse(readFileSync(getManagedResourceManifestPath(agentDir), 'utf-8'));
-        return typeof manifest?.syncedAt === 'number' ? manifest.syncedAt : null;
-    }
-    catch {
-        return null;
-    }
-}
 export function getNewerManagedResourceVersion(agentDir, currentVersion) {
     const managedVersion = readManagedResourceVersion(agentDir);
     if (!managedVersion) {
@@ -113,6 +104,38 @@ export function getNewerManagedResourceVersion(agentDir, currentVersion) {
     }
     return compareSemver(managedVersion, currentVersion) > 0 ? managedVersion : null;
 }
+/**
+ * Recursively makes all files and directories under dirPath owner-writable.
+ *
+ * Files copied from the Nix store inherit read-only modes (0444/0555).
+ * Calling this before cpSync prevents overwrite failures on subsequent upgrades,
+ * and calling it after ensures the next run can overwrite the copies too.
+ *
+ * Preserves existing permission bits (including executability) and only adds
+ * owner-write (and for directories, owner-exec) without widening group/other
+ * permissions.
+ */
+function makeTreeWritable(dirPath) {
+    if (!existsSync(dirPath))
+        return;
+    const stats = statSync(dirPath);
+    const isDir = stats.isDirectory();
+    const currentMode = stats.mode & 0o777;
+    // Ensure owner-write; for directories also ensure owner-exec so they remain traversable.
+    let newMode = currentMode | 0o200;
+    if (isDir) {
+        newMode |= 0o100;
+    }
+    if (newMode !== currentMode) {
+        chmodSync(dirPath, newMode);
+    }
+    if (isDir) {
+        for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+            const entryPath = join(dirPath, entry.name);
+            makeTreeWritable(entryPath);
+        }
+    }
+}
 /**
  * Syncs all bundled resources to agentDir (~/.gsd/agent/) on every launch.
  *
@@ -130,26 +153,49 @@ export function getNewerManagedResourceVersion(agentDir, currentVersion) {
  */
 export function initResources(agentDir) {
     mkdirSync(agentDir, { recursive: true });
-    // Skip resource sync when versions match — saves ~128ms of cpSync per launch
-    const currentVersion = getBundledGsdVersion();
-    const managedVersion = readManagedResourceVersion(agentDir);
-    if (managedVersion && managedVersion === currentVersion) {
-        return;
-    }
-    // Sync extensions — overwrite so updates land on next launch
+    // Sync extensions — clean bundled subdirs first to remove stale leftover files,
+    // then overwrite so updates land on next launch. Only bundled subdirs are removed;
+    // user-created extension directories are preserved.
     const destExtensions = join(agentDir, 'extensions');
+    makeTreeWritable(destExtensions);
+    for (const entry of readdirSync(bundledExtensionsDir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+            const target = join(destExtensions, entry.name);
+            if (existsSync(target))
+                rmSync(target, { recursive: true, force: true });
+        }
+    }
     cpSync(bundledExtensionsDir, destExtensions, { recursive: true, force: true });
+    makeTreeWritable(destExtensions);
     // Sync agents
     const destAgents = join(agentDir, 'agents');
     const srcAgents = join(resourcesDir, 'agents');
     if (existsSync(srcAgents)) {
+        makeTreeWritable(destAgents);
+        for (const entry of readdirSync(srcAgents, { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+                const target = join(destAgents, entry.name);
+                if (existsSync(target))
+                    rmSync(target, { recursive: true, force: true });
+            }
+        }
         cpSync(srcAgents, destAgents, { recursive: true, force: true });
+        makeTreeWritable(destAgents);
     }
-    // Sync skills — overwrite so updates land on next launch
+    // Sync skills
     const destSkills = join(agentDir, 'skills');
     const srcSkills = join(resourcesDir, 'skills');
     if (existsSync(srcSkills)) {
+        makeTreeWritable(destSkills);
+        for (const entry of readdirSync(srcSkills, { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+                const target = join(destSkills, entry.name);
+                if (existsSync(target))
+                    rmSync(target, { recursive: true, force: true });
+            }
+        }
         cpSync(srcSkills, destSkills, { recursive: true, force: true });
+        makeTreeWritable(destSkills);
     }
     writeManagedResourceManifest(agentDir);
 }

package/dist/resources/GSD-WORKFLOW.md

@@ -565,25 +565,28 @@ One commit per slice. Individually revertable. Reads like a changelog.
 
 ```
 gsd/M001/S01:
-  test(S01): round-trip tests passing
+  test(S01/T03): round-trip tests passing
   feat(S01/T03): file writer with round-trip fidelity
-  chore(S01/T03): auto-commit after task
   feat(S01/T02): markdown parser for plan files
-  chore(S01/T02): auto-commit after task
   feat(S01/T01): core types and interfaces
-  chore(S01/T01): auto-commit after task
+  docs(S01): add slice plan
 ```
 
 ### Commit Conventions
 
 | When | Format | Example |
 |------|--------|---------|
-| Auto-commit (dirty state) | `chore(S01/T02): auto-commit after task` | Automatic save of work in progress |
-| After task verified | `feat(S01/T02): <what was built>` | The real work |
-| Plan/docs committed | `docs(S01): add slice plan` | Bundled with first task |
-| Slice squash to main | `type(M001/S01): <slice title>` | Type inferred from title (`feat`, `fix`, `docs`, etc.) |
+| Task completed | `{type}(S01/T02): <one-liner from summary>` | Type inferred from title (`feat`, `fix`, `test`, etc.) |
+| Plan/docs committed | `docs(S01): add slice plan` | Planning artifacts |
+| Slice squash to main | `type(M001/S01): <slice title>` | Type inferred from title |
+| State rebuild | `chore(S01/T02): auto-commit after state-rebuild` | Bookkeeping only |
 
-Commit types: `feat`, `fix`, `test`, `refactor`, `docs`, `chore`
+The system reads the task summary after execution and builds a meaningful commit message:
+- **Subject**: `{type}({sliceId}/{taskId}): {one-liner}` — the one-liner from the summary frontmatter
+- **Type**: Inferred from the task title and one-liner (`feat`, `fix`, `test`, `refactor`, `docs`, `perf`, `chore`)
+- **Body**: Key files from the summary frontmatter (up to 8 files listed)
+
+Commit types: `feat`, `fix`, `test`, `refactor`, `docs`, `perf`, `chore`
 
 ### Squash Merge Message
 

package/dist/resources/extensions/bg-shell/overlay.ts

@@ -328,12 +328,9 @@ export class BgManagerOverlay {
 		return this.box(inner, width);
 	}
 
-	private renderOutput(width: number): string[] {
+	private processStatusHeader(p: typeof this.viewingProcess, activeTab: "output" | "events"): { statusIcon: string; headerLine: string } {
 		const th = this.theme;
-		const p = this.viewingProcess;
-		if (!p) return [""];
-		const inner: string[] = [];
-
+		if (!p) return { statusIcon: "", headerLine: "" };
 		const statusIcon = p.alive
 			? (p.status === "ready" ? th.fg("success", "●")
 				: p.status === "error" ? th.fg("error", "●")
@@ -343,9 +340,21 @@ export class BgManagerOverlay {
 		const uptime = th.fg("dim", formatUptime(Date.now() - p.startedAt));
 		const typeTag = th.fg("dim", `[${p.processType}]`);
 		const portInfo = p.ports.length > 0 ? th.fg("dim", ` :${p.ports.join(",")}`) : "";
-		const tabIndicator = th.fg("accent", "[Output]") + " " + th.fg("dim", "Events");
+		const tabIndicator = activeTab === "output"
+			? th.fg("accent", "[Output]") + " " + th.fg("dim", "Events")
+			: th.fg("dim", "Output") + " " + th.fg("accent", "[Events]");
+		const headerLine = `${statusIcon} ${name} ${typeTag} ${uptime}${portInfo}  ${tabIndicator}`;
+		return { statusIcon, headerLine };
+	}
+
+	private renderOutput(width: number): string[] {
+		const th = this.theme;
+		const p = this.viewingProcess;
+		if (!p) return [""];
+		const inner: string[] = [];
 
-		inner.push(`${statusIcon} ${name} ${typeTag} ${uptime}${portInfo}  ${tabIndicator}`);
+		const { headerLine } = this.processStatusHeader(p, "output");
+		inner.push(headerLine);
 		inner.push("");
 
 		// Unified buffer is already chronologically interleaved
@@ -384,16 +393,8 @@ export class BgManagerOverlay {
 		if (!p) return [""];
 		const inner: string[] = [];
 
-		const statusIcon = p.alive
-			? (p.status === "ready" ? th.fg("success", "●")
-				: p.status === "error" ? th.fg("error", "●")
-				: th.fg("warning", "●"))
-			: th.fg("dim", "○");
-		const name = th.fg("muted", p.label);
-		const uptime = th.fg("dim", formatUptime(Date.now() - p.startedAt));
-		const tabIndicator = th.fg("dim", "Output") + " " + th.fg("accent", "[Events]");
-
-		inner.push(`${statusIcon} ${name} ${uptime}  ${tabIndicator}`);
+		const { headerLine } = this.processStatusHeader(p, "events");
+		inner.push(headerLine);
 		inner.push("");
 
 		if (p.events.length === 0) {

package/dist/resources/extensions/get-secrets-from-user.ts

@@ -369,32 +369,14 @@ async function applySecrets(
 		}
 	}
 
-	if (destination === "vercel" && opts.exec) {
+	if ((destination === "vercel" || destination === "convex") && opts.exec) {
 		const env = opts.environment ?? "development";
 		for (const { key, value } of provided) {
+			const cmd = destination === "vercel"
+				? `printf %s ${shellEscapeSingle(value)} | vercel env add ${key} ${env}`
+				: `npx convex env set ${key} ${shellEscapeSingle(value)}`;
 			try {
-				const result = await opts.exec("sh", [
-					"-c",
-					`printf %s ${shellEscapeSingle(value)} | vercel env add ${key} ${env}`,
-				]);
-				if (result.code !== 0) {
-					errors.push(`${key}: ${result.stderr.slice(0, 200)}`);
-				} else {
-					applied.push(key);
-				}
-			} catch (err: any) {
-				errors.push(`${key}: ${err.message}`);
-			}
-		}
-	}
-
-	if (destination === "convex" && opts.exec) {
-		for (const { key, value } of provided) {
-			try {
-				const result = await opts.exec("sh", [
-					"-c",
-					`npx convex env set ${key} ${shellEscapeSingle(value)}`,
-				]);
+				const result = await opts.exec("sh", ["-c", cmd]);
 				if (result.code !== 0) {
 					errors.push(`${key}: ${result.stderr.slice(0, 200)}`);
 				} else {

package/dist/resources/extensions/gsd/activity-log.ts

@@ -103,10 +103,10 @@ export function saveActivityLog(
   basePath: string,
   unitType: string,
   unitId: string,
-): void {
+): string | null {
   try {
     const entries = ctx.sessionManager.getEntries();
-    if (!entries || entries.length === 0) return;
+    if (!entries || entries.length === 0) return null;
 
     const activityDir = join(gsdRoot(basePath), "activity");
     mkdirSync(activityDir, { recursive: true });
@@ -116,7 +116,7 @@ export function saveActivityLog(
     const unitKey = `${unitType}\0${safeUnitId}`;
     // Use lightweight fingerprint instead of serializing all entries (#611)
     const key = snapshotKey(unitType, safeUnitId, entries);
-    if (state.lastSnapshotKeyByUnit.get(unitKey) === key) return;
+    if (state.lastSnapshotKeyByUnit.get(unitKey) === key) return null;
 
     const filePath = nextActivityFilePath(activityDir, state, unitType, safeUnitId);
     // Stream entries to disk line-by-line instead of building one massive string (#611).
@@ -131,9 +131,11 @@ export function saveActivityLog(
     }
     state.nextSeq += 1;
     state.lastSnapshotKeyByUnit.set(unitKey, key);
+    return filePath;
   } catch (e) {
     // Don't let logging failures break auto-mode
     void e;
+    return null;
   }
 }