gsd-pi 2.57.0 → 2.58.0

package/packages/daemon/src/launchd.test.ts

@@ -0,0 +1,356 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, existsSync, readFileSync, writeFileSync, rmSync, mkdirSync, statSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { tmpdir, homedir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import {
+  escapeXml,
+  generatePlist,
+  getPlistPath,
+  install,
+  uninstall,
+  status,
+} from './launchd.js';
+import type { PlistOptions, RunCommandFn, LaunchdStatus } from './launchd.js';
+
+// ---------- helpers ----------
+
+function tmpDir(): string {
+  return mkdtempSync(join(tmpdir(), `launchd-test-${randomUUID().slice(0, 8)}-`));
+}
+
+const cleanupDirs: string[] = [];
+afterEach(() => {
+  while (cleanupDirs.length) {
+    const d = cleanupDirs.pop()!;
+    if (existsSync(d)) rmSync(d, { recursive: true, force: true });
+  }
+});
+
+function basePlistOpts(overrides?: Partial<PlistOptions>): PlistOptions {
+  return {
+    nodePath: '/usr/local/bin/node',
+    scriptPath: '/usr/local/lib/gsd-daemon/dist/cli.js',
+    configPath: join(homedir(), '.gsd', 'daemon.yaml'),
+    ...overrides,
+  };
+}
+
+// ---------- escapeXml ----------
+
+describe('escapeXml', () => {
+  it('escapes & < > " \'', () => {
+    assert.equal(escapeXml('a&b<c>d"e\'f'), 'a&amp;b&lt;c&gt;d&quot;e&apos;f');
+  });
+
+  it('leaves plain strings untouched', () => {
+    assert.equal(escapeXml('/usr/local/bin/node'), '/usr/local/bin/node');
+  });
+
+  it('escapes paths with spaces and special chars', () => {
+    const input = '/Users/John & Jane/my "project"/file.js';
+    const output = escapeXml(input);
+    assert.ok(output.includes('&amp;'));
+    assert.ok(output.includes('&quot;'));
+    // Verify no raw unescaped & remain (all & are part of &amp; &lt; etc.)
+    assert.equal(output, '/Users/John &amp; Jane/my &quot;project&quot;/file.js');
+  });
+});
+
+// ---------- generatePlist ----------
+
+describe('generatePlist', () => {
+  it('produces valid XML with plist header', () => {
+    const xml = generatePlist(basePlistOpts());
+    assert.ok(xml.startsWith('<?xml version="1.0"'));
+    assert.ok(xml.includes('<!DOCTYPE plist'));
+    assert.ok(xml.includes('<plist version="1.0">'));
+    assert.ok(xml.includes('</plist>'));
+  });
+
+  it('includes label com.gsd.daemon', () => {
+    const xml = generatePlist(basePlistOpts());
+    assert.ok(xml.includes('<string>com.gsd.daemon</string>'));
+  });
+
+  it('uses the absolute node path from opts', () => {
+    const opts = basePlistOpts({ nodePath: '/home/user/.nvm/versions/node/v22.0.0/bin/node' });
+    const xml = generatePlist(opts);
+    assert.ok(xml.includes('<string>/home/user/.nvm/versions/node/v22.0.0/bin/node</string>'));
+  });
+
+  it('includes NVM bin directory in PATH', () => {
+    const opts = basePlistOpts({ nodePath: '/home/user/.nvm/versions/node/v22.0.0/bin/node' });
+    const xml = generatePlist(opts);
+    assert.ok(xml.includes('/home/user/.nvm/versions/node/v22.0.0/bin'));
+  });
+
+  it('sets KeepAlive with SuccessfulExit false', () => {
+    const xml = generatePlist(basePlistOpts());
+    assert.ok(xml.includes('<key>KeepAlive</key>'));
+    assert.ok(xml.includes('<key>SuccessfulExit</key>'));
+    assert.ok(xml.includes('<false/>'));
+  });
+
+  it('sets RunAtLoad true', () => {
+    const xml = generatePlist(basePlistOpts());
+    assert.ok(xml.includes('<key>RunAtLoad</key>'));
+    assert.ok(xml.includes('<true/>'));
+  });
+
+  it('includes --config with the config path', () => {
+    const configPath = '/custom/path/daemon.yaml';
+    const xml = generatePlist(basePlistOpts({ configPath }));
+    assert.ok(xml.includes('<string>--config</string>'));
+    assert.ok(xml.includes(`<string>${configPath}</string>`));
+  });
+
+  it('includes HOME environment variable', () => {
+    const xml = generatePlist(basePlistOpts());
+    assert.ok(xml.includes('<key>HOME</key>'));
+    assert.ok(xml.includes(`<string>${homedir()}</string>`));
+  });
+
+  it('includes StandardOutPath and StandardErrorPath', () => {
+    const xml = generatePlist(basePlistOpts());
+    assert.ok(xml.includes('<key>StandardOutPath</key>'));
+    assert.ok(xml.includes('<key>StandardErrorPath</key>'));
+  });
+
+  it('escapes special characters in paths', () => {
+    const opts = basePlistOpts({
+      configPath: '/Users/John & Jane/config.yaml',
+    });
+    const xml = generatePlist(opts);
+    assert.ok(xml.includes('John &amp; Jane'));
+    assert.ok(!xml.includes('John & Jane'));
+  });
+
+  it('uses custom stdout/stderr paths when provided', () => {
+    const opts = basePlistOpts({
+      stdoutPath: '/tmp/my-stdout.log',
+      stderrPath: '/tmp/my-stderr.log',
+    });
+    const xml = generatePlist(opts);
+    assert.ok(xml.includes('<string>/tmp/my-stdout.log</string>'));
+    assert.ok(xml.includes('<string>/tmp/my-stderr.log</string>'));
+  });
+
+  it('uses custom working directory when provided', () => {
+    const opts = basePlistOpts({
+      workingDirectory: '/custom/work/dir',
+    });
+    const xml = generatePlist(opts);
+    assert.ok(xml.includes('<string>/custom/work/dir</string>'));
+  });
+});
+
+// ---------- getPlistPath ----------
+
+describe('getPlistPath', () => {
+  it('returns ~/Library/LaunchAgents/com.gsd.daemon.plist', () => {
+    const expected = join(homedir(), 'Library', 'LaunchAgents', 'com.gsd.daemon.plist');
+    assert.equal(getPlistPath(), expected);
+  });
+});
+
+// ---------- install ----------
+
+describe('install', () => {
+  let tmp: string;
+  let fakePlistPath: string;
+
+  // We can't mock getPlistPath directly, but we can verify the commands
+  // issued and the plist content by intercepting runCommand and filesystem ops.
+  // For filesystem testing, we test the functions that call writeFileSync indirectly
+  // by verifying the runCommand calls and returned values.
+
+  it('calls launchctl load with the plist path', () => {
+    const calls: string[] = [];
+    const mockRun: RunCommandFn = (cmd: string) => {
+      calls.push(cmd);
+      return '';
+    };
+
+    // install will try to write to the real plist path, so we need to be careful.
+    // We test the command flow by catching the writeFileSync error (dir may not exist in CI)
+    // or by letting it proceed in local dev.
+    try {
+      install(basePlistOpts(), mockRun);
+    } catch {
+      // writeFileSync may fail if ~/Library/LaunchAgents doesn't exist in test env
+    }
+
+    const loadCalls = calls.filter(c => c.startsWith('launchctl load'));
+    const listCalls = calls.filter(c => c.startsWith('launchctl list'));
+    // Should have at least attempted launchctl load
+    assert.ok(loadCalls.length > 0 || calls.length > 0, 'Expected launchctl commands to be called');
+  });
+
+  it('generates valid plist content when called', () => {
+    // Test that the plist content would be correct by testing generatePlist
+    // (install is a thin wrapper around generatePlist + writeFile + launchctl)
+    const xml = generatePlist(basePlistOpts());
+    assert.ok(xml.includes('<key>Label</key>'));
+    assert.ok(xml.includes('<string>com.gsd.daemon</string>'));
+  });
+
+  it('handles idempotent install (unloads first if plist exists)', () => {
+    const calls: string[] = [];
+    const mockRun: RunCommandFn = (cmd: string) => {
+      calls.push(cmd);
+      return '';
+    };
+
+    // To simulate idempotent install, we need an existing plist file.
+    // Since install writes to getPlistPath(), we test the command sequence.
+    try {
+      install(basePlistOpts(), mockRun);
+      // Second install
+      install(basePlistOpts(), mockRun);
+    } catch {
+      // filesystem may not be writable
+    }
+
+    // The second install should have tried to unload first
+    const unloadCalls = calls.filter(c => c.startsWith('launchctl unload'));
+    // If the plist path exists, we expect at least one unload attempt on second call
+    // This is a command-level check; filesystem existence depends on environment
+  });
+});
+
+// ---------- uninstall ----------
+
+describe('uninstall', () => {
+  it('calls launchctl unload when plist would exist', () => {
+    const calls: string[] = [];
+    const mockRun: RunCommandFn = (cmd: string) => {
+      calls.push(cmd);
+      return '';
+    };
+
+    // uninstall checks existsSync(plistPath) — if plist doesn't exist, it's a no-op
+    uninstall(mockRun);
+
+    // If plist doesn't exist in test environment, calls should be empty (graceful)
+    // That's the "handles missing plist gracefully" case
+  });
+
+  it('handles missing plist gracefully (no-op)', () => {
+    const calls: string[] = [];
+    const mockRun: RunCommandFn = (cmd: string) => {
+      calls.push(cmd);
+      return '';
+    };
+
+    // Shouldn't throw even if plist doesn't exist
+    assert.doesNotThrow(() => uninstall(mockRun));
+  });
+
+  it('handles already-unloaded agent gracefully', () => {
+    const mockRun: RunCommandFn = (cmd: string) => {
+      if (cmd.includes('launchctl unload')) {
+        throw new Error('Could not find specified service');
+      }
+      return '';
+    };
+
+    // Should not throw even if launchctl unload fails
+    assert.doesNotThrow(() => uninstall(mockRun));
+  });
+});
+
+// ---------- status ----------
+
+describe('status', () => {
+  it('parses running daemon output (PID present)', () => {
+    const mockRun: RunCommandFn = (_cmd: string) => {
+      return '{\n\t"PID" = 1234;\n\t"Label" = "com.gsd.daemon";\n}\nPID\tStatus\tLabel\n1234\t0\tcom.gsd.daemon\n';
+    };
+
+    const result = status(mockRun);
+    assert.equal(result.registered, true);
+    assert.equal(result.pid, 1234);
+    assert.equal(result.lastExitStatus, 0);
+  });
+
+  it('parses stopped daemon output (no PID)', () => {
+    const mockRun: RunCommandFn = (_cmd: string) => {
+      return 'PID\tStatus\tLabel\n-\t78\tcom.gsd.daemon\n';
+    };
+
+    const result = status(mockRun);
+    assert.equal(result.registered, true);
+    assert.equal(result.pid, null);
+    assert.equal(result.lastExitStatus, 78);
+  });
+
+  it('returns not-registered when launchctl list fails', () => {
+    const mockRun: RunCommandFn = (_cmd: string) => {
+      throw new Error('Could not find service "com.gsd.daemon" in domain for port');
+    };
+
+    const result = status(mockRun);
+    assert.equal(result.registered, false);
+    assert.equal(result.pid, null);
+    assert.equal(result.lastExitStatus, null);
+  });
+
+  it('returns structured result with all fields', () => {
+    const mockRun: RunCommandFn = (_cmd: string) => {
+      return 'PID\tStatus\tLabel\n5678\t0\tcom.gsd.daemon\n';
+    };
+
+    const result = status(mockRun);
+    assert.ok('registered' in result);
+    assert.ok('pid' in result);
+    assert.ok('lastExitStatus' in result);
+  });
+
+  it('parses JSON-style dict output (newer macOS)', () => {
+    const mockRun: RunCommandFn = (_cmd: string) => {
+      return `{
+\t"StandardOutPath" = "/Users/me/.gsd/daemon-stdout.log";
+\t"LimitLoadToSessionType" = "Aqua";
+\t"StandardErrorPath" = "/Users/me/.gsd/daemon-stderr.log";
+\t"Label" = "com.gsd.daemon";
+\t"OnDemand" = true;
+\t"LastExitStatus" = 0;
+\t"PID" = 23802;
+\t"Program" = "/usr/local/bin/node";
+};`;
+    };
+
+    const result = status(mockRun);
+    assert.equal(result.registered, true);
+    assert.equal(result.pid, 23802);
+    assert.equal(result.lastExitStatus, 0);
+  });
+
+  it('parses JSON-style dict output when daemon stopped (no PID key)', () => {
+    const mockRun: RunCommandFn = (_cmd: string) => {
+      return `{
+\t"Label" = "com.gsd.daemon";
+\t"LastExitStatus" = 1;
+\t"OnDemand" = true;
+};`;
+    };
+
+    const result = status(mockRun);
+    assert.equal(result.registered, true);
+    assert.equal(result.pid, null);
+    assert.equal(result.lastExitStatus, 1);
+  });
+
+  it('handles unexpected output format gracefully', () => {
+    const mockRun: RunCommandFn = (_cmd: string) => {
+      return 'some unexpected output without the label';
+    };
+
+    // Should not throw — should return registered:true but with null fields
+    // since the command succeeded (label was found) but output didn't match
+    const result = status(mockRun);
+    assert.equal(result.registered, true);
+  });
+});

package/packages/daemon/src/launchd.ts

@@ -0,0 +1,242 @@
+import { writeFileSync, unlinkSync, existsSync, chmodSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { execSync } from 'node:child_process';
+import { dirname } from 'node:path';
+
+// --------------- types ---------------
+
+export interface PlistOptions {
+  /** Absolute path to the Node.js binary */
+  nodePath: string;
+  /** Absolute path to the daemon script (cli.js) */
+  scriptPath: string;
+  /** Absolute path to the config file */
+  configPath: string;
+  /** Directory to use as WorkingDirectory in the plist (defaults to homedir) */
+  workingDirectory?: string;
+  /** Override stdout log path */
+  stdoutPath?: string;
+  /** Override stderr log path */
+  stderrPath?: string;
+}
+
+export interface LaunchdStatus {
+  /** Whether the daemon is registered with launchd */
+  registered: boolean;
+  /** PID if currently running, null otherwise */
+  pid: number | null;
+  /** Last exit status code, null if never exited or not available */
+  lastExitStatus: number | null;
+}
+
+export type RunCommandFn = (cmd: string) => string;
+
+// --------------- constants ---------------
+
+const LABEL = 'com.gsd.daemon';
+const PLIST_FILENAME = `${LABEL}.plist`;
+
+// --------------- helpers ---------------
+
+/** Escape special XML characters in a string. */
+export function escapeXml(str: string): string {
+  return str
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+/** Return the canonical plist path under ~/Library/LaunchAgents/. */
+export function getPlistPath(): string {
+  return resolve(homedir(), 'Library', 'LaunchAgents', PLIST_FILENAME);
+}
+
+/**
+ * Build the NVM-aware PATH string.
+ * Includes the directory containing the Node binary so that launchd can find node
+ * even when launched outside a shell session (where NVM isn't sourced).
+ */
+function buildEnvPath(nodePath: string): string {
+  const nodeBinDir = dirname(nodePath);
+  // Keep system essentials and prepend the node binary's directory
+  return `${nodeBinDir}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin`;
+}
+
+// --------------- plist generation ---------------
+
+/** Generate valid launchd plist XML for the GSD daemon. */
+export function generatePlist(opts: PlistOptions): string {
+  const home = homedir();
+  const workDir = opts.workingDirectory ?? home;
+  const stdoutPath = opts.stdoutPath ?? resolve(home, '.gsd', 'daemon-stdout.log');
+  const stderrPath = opts.stderrPath ?? resolve(home, '.gsd', 'daemon-stderr.log');
+  const envPath = buildEnvPath(opts.nodePath);
+
+  // Forward ANTHROPIC_API_KEY so the orchestrator LLM can authenticate.
+  // Captured at install time from the current process environment.
+  const anthropicKey = process.env.ANTHROPIC_API_KEY;
+  const anthropicKeyXml = anthropicKey
+    ? `\n\t\t<key>ANTHROPIC_API_KEY</key>\n\t\t<string>${escapeXml(anthropicKey)}</string>`
+    : '';
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+\t<key>Label</key>
+\t<string>${escapeXml(LABEL)}</string>
+
+\t<key>ProgramArguments</key>
+\t<array>
+\t\t<string>${escapeXml(opts.nodePath)}</string>
+\t\t<string>${escapeXml(opts.scriptPath)}</string>
+\t\t<string>--config</string>
+\t\t<string>${escapeXml(opts.configPath)}</string>
+\t</array>
+
+\t<key>KeepAlive</key>
+\t<dict>
+\t\t<key>SuccessfulExit</key>
+\t\t<false/>
+\t</dict>
+
+\t<key>RunAtLoad</key>
+\t<true/>
+
+\t<key>EnvironmentVariables</key>
+\t<dict>
+\t\t<key>PATH</key>
+\t\t<string>${escapeXml(envPath)}</string>
+\t\t<key>HOME</key>
+\t\t<string>${escapeXml(home)}</string>${anthropicKeyXml}
+\t</dict>
+
+\t<key>WorkingDirectory</key>
+\t<string>${escapeXml(workDir)}</string>
+
+\t<key>StandardOutPath</key>
+\t<string>${escapeXml(stdoutPath)}</string>
+
+\t<key>StandardErrorPath</key>
+\t<string>${escapeXml(stderrPath)}</string>
+</dict>
+</plist>
+`;
+}
+
+// --------------- install / uninstall / status ---------------
+
+/** Default runCommand using execSync. */
+function defaultRunCommand(cmd: string): string {
+  return execSync(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+}
+
+/**
+ * Install the launchd agent: write plist and load it.
+ * Idempotent — unloads first if already loaded.
+ */
+export function install(
+  opts: PlistOptions,
+  runCommand: RunCommandFn = defaultRunCommand,
+): void {
+  const plistPath = getPlistPath();
+  const xml = generatePlist(opts);
+
+  // Unload first if already present (ignore errors)
+  if (existsSync(plistPath)) {
+    try {
+      runCommand(`launchctl unload ${plistPath}`);
+    } catch {
+      // already unloaded — fine
+    }
+  }
+
+  writeFileSync(plistPath, xml, 'utf-8');
+  chmodSync(plistPath, 0o644);
+
+  runCommand(`launchctl load ${plistPath}`);
+
+  // Verify it loaded
+  try {
+    runCommand(`launchctl list ${LABEL}`);
+  } catch {
+    throw new Error(
+      `Plist was written to ${plistPath} and launchctl load succeeded, but launchctl list ${LABEL} failed. The agent may not have started.`,
+    );
+  }
+}
+
+/**
+ * Uninstall the launchd agent: unload and remove plist.
+ * Graceful — does not throw if already uninstalled.
+ */
+export function uninstall(runCommand: RunCommandFn = defaultRunCommand): void {
+  const plistPath = getPlistPath();
+
+  if (existsSync(plistPath)) {
+    try {
+      runCommand(`launchctl unload ${plistPath}`);
+    } catch {
+      // already unloaded — that's fine
+    }
+    unlinkSync(plistPath);
+  }
+  // If plist doesn't exist, nothing to do — already uninstalled
+}
+
+/**
+ * Query launchd for the daemon's status.
+ * Returns structured information about registration, PID, and last exit code.
+ *
+ * Handles two launchctl output formats:
+ * 1. Tabular: "PID\tStatus\tLabel" (older macOS)
+ * 2. JSON-style dict: `"PID" = 1234;` / `"LastExitStatus" = 0;` (newer macOS)
+ */
+export function status(runCommand: RunCommandFn = defaultRunCommand): LaunchdStatus {
+  try {
+    const output = runCommand(`launchctl list ${LABEL}`);
+
+    // --- Try tabular format first ---
+    const lines = output.trim().split('\n');
+    for (const line of lines) {
+      const parts = line.trim().split(/\t+/);
+      if (parts.length >= 3 && parts[2] === LABEL) {
+        const pidStr = parts[0];
+        const statusStr = parts[1];
+
+        const pid = pidStr === '-' ? null : parseInt(pidStr, 10);
+        const lastExitStatus = statusStr != null ? parseInt(statusStr, 10) : null;
+
+        return {
+          registered: true,
+          pid: Number.isNaN(pid!) ? null : pid,
+          lastExitStatus: Number.isNaN(lastExitStatus!) ? null : lastExitStatus,
+        };
+      }
+    }
+
+    // --- Try JSON-style dict format ---
+    // Matches: "PID" = 1234;  or  "LastExitStatus" = 0;
+    const pidMatch = output.match(/"PID"\s*=\s*(\d+)\s*;/);
+    const exitMatch = output.match(/"LastExitStatus"\s*=\s*(\d+)\s*;/);
+
+    if (pidMatch || exitMatch) {
+      const pid = pidMatch ? parseInt(pidMatch[1], 10) : null;
+      const lastExitStatus = exitMatch ? parseInt(exitMatch[1], 10) : null;
+      return {
+        registered: true,
+        pid: Number.isNaN(pid!) ? null : pid,
+        lastExitStatus: Number.isNaN(lastExitStatus!) ? null : lastExitStatus,
+      };
+    }
+
+    // Label resolved (no error) but no parseable output — still registered
+    return { registered: true, pid: null, lastExitStatus: null };
+  } catch {
+    // launchctl list exits non-zero when the label isn't found
+    return { registered: false, pid: null, lastExitStatus: null };
+  }
+}

package/packages/pi-coding-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd/pi-coding-agent",
-  "version": "2.57.0",
+  "version": "2.58.0",
   "description": "Coding agent CLI (vendored from pi-mono)",
   "type": "module",
   "piConfig": {

package/pkg/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glittercowboy/gsd",
-  "version": "2.57.0",
+  "version": "2.58.0",
   "piConfig": {
     "name": "gsd",
     "configDir": ".gsd"

package/src/resources/extensions/gsd/auto/infra-errors.ts

@@ -41,5 +41,8 @@ export function isInfrastructureError(err: unknown): string | null {
   for (const code of INFRA_ERROR_CODES) {
     if (msg.includes(code)) return code;
   }
+  // SQLite WAL corruption is not transient — retrying burns LLM budget
+  // for guaranteed failures (#2823).
+  if (msg.includes("database disk image is malformed")) return "SQLITE_CORRUPT";
   return null;
 }

package/src/resources/extensions/gsd/auto-dispatch.ts

@@ -677,13 +677,13 @@ export const DISPATCH_RULES: DispatchRule[] = [
             if (validationPath) {
               const validationContent = await loadFile(validationPath);
               if (validationContent) {
-                // Accept either the structured template format (table with MET/N/A)
+                // Accept either the structured template format (table with MET/N/A/SATISFIED)
                 // or prose evidence patterns the validation agent may emit.
                 const structuredMatch =
                   validationContent.includes("Operational") &&
-                  (validationContent.includes("MET") || validationContent.includes("N/A"));
+                  (validationContent.includes("MET") || validationContent.includes("N/A") || validationContent.includes("SATISFIED"));
                 const proseMatch =
-                  /[Oo]perational[\s:][^\n]*(?:pass|verified|confirmed|met|complete|true|yes|addressed|covered|n\/a|not\s+applicable)/i.test(validationContent);
+                  /[Oo]perational[\s\S]{0,500}?(?:✅|pass|verified|confirmed|met|complete|true|yes|addressed|covered|satisfied|partially|n\/a|not[\s-]+applicable)/i.test(validationContent);
                 const hasOperationalCheck = structuredMatch || proseMatch;
                 if (!hasOperationalCheck) {
                   return {

package/src/resources/extensions/gsd/auto-worktree.ts

@@ -1264,12 +1264,17 @@ export function mergeMilestoneToMain(
   // 1. Auto-commit dirty state in worktree before leaving
   autoCommitDirtyState(worktreeCwd);
 
-  // Reconcile worktree DB into main DB before leaving worktree context
+  // Reconcile worktree DB into main DB before leaving worktree context.
+  // Skip when both paths resolve to the same physical file (shared WAL /
+  // symlink layout) — ATTACHing a WAL-mode file to itself corrupts the
+  // database (#2823).
   if (isDbAvailable()) {
     try {
       const worktreeDbPath = join(worktreeCwd, ".gsd", "gsd.db");
       const mainDbPath = join(originalBasePath_, ".gsd", "gsd.db");
-      reconcileWorktreeDb(mainDbPath, worktreeDbPath);
+      if (!isSamePath(worktreeDbPath, mainDbPath)) {
+        reconcileWorktreeDb(mainDbPath, worktreeDbPath);
+      }
     } catch {
       /* non-fatal */
     }

package/src/resources/extensions/gsd/auto.ts

@@ -1061,6 +1061,11 @@ export async function startAuto(
   verboseMode: boolean,
   options?: { step?: boolean },
 ): Promise<void> {
+  if (s.active) {
+    debugLog("startAuto", { phase: "already-active", skipping: true });
+    return;
+  }
+
   const requestedStepMode = options?.step ?? false;
 
   // Escape stale worktree cwd from a previous milestone (#608).