@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.5fc22c6f

package/dist/resources/extensions/gsd/doctor.js

@@ -1,16 +1,20 @@
-import { existsSync, mkdirSync, lstatSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, mkdirSync, lstatSync, readdirSync, readFileSync, realpathSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { execFileSync } from "node:child_process";
 import { loadFile, parseSummary, saveFile, parseTaskPlanMustHaves, countMustHavesMentionedInSummary } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { openExistingWorkflowDatabase } from "./db-workspace.js";
-import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, milestonesDir, gsdRoot, relMilestoneFile, relSliceFile, relTaskFile, relSlicePath, relGsdRootFile, resolveGsdRootFile, relMilestonePath } from "./paths.js";
+import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, milestonesDir, legacyMilestonesDir, gsdRoot, relMilestoneFile, relSliceFile, relTaskFile, relSlicePath, relGsdRootFile, resolveGsdRootFile, relMilestonePath } from "./paths.js";
+import { findMilestoneIds } from "./milestone-ids.js";
 import { deriveState, isMilestoneComplete } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { collectPreferenceDiagnostics, formatPreferenceDiagnosticDetail } from "./preferences-diagnostics.js";
 import { isClosedStatus } from "./status-guards.js";
 import { GLOBAL_STATE_CODES } from "./doctor-types.js";
+import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
+import { createRepositoryRegistryFromPreferences } from "./repository-registry.js";
 import { checkGitHealth, checkRuntimeHealth, checkGlobalHealth, checkEngineHealth } from "./doctor-checks.js";
 import { checkEnvironmentHealth } from "./doctor-environment.js";
 import { runProviderChecks } from "./doctor-providers.js";
@@ -171,7 +175,8 @@ export async function selectDoctorScope(basePath, requestedScope) {
         return state.activeMilestone.id;
     }
     const milestonesPath = milestonesDir(basePath);
-    if (!existsSync(milestonesPath))
+    const legacyMilestonesPath = legacyMilestonesDir(basePath);
+    if (!existsSync(milestonesPath) && !existsSync(legacyMilestonesPath))
         return undefined;
     for (const milestone of state.registry) {
         const roadmapPath = resolveMilestoneFile(basePath, milestone.id, "ROADMAP");
@@ -279,6 +284,92 @@ export async function readDoctorHistory(basePath, lastN = 50) {
         return [];
     }
 }
+/**
+ * Resolve the git working-tree root for a path, or null if it is not a repo.
+ * Used by the workspace-repository probe to check that a declared child path is
+ * itself a git repository (not merely nested inside the parent's repo).
+ */
+function resolveGitToplevel(cwd) {
+    try {
+        const out = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+            env: GIT_NO_PROMPT_ENV,
+        }).trim();
+        return out ? resolve(out) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** realpath that falls back to the resolved path if the link cannot be read. */
+function realpathSafe(p) {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return resolve(p);
+    }
+}
+/**
+ * Parent-workspace probe (#818): validate that every declared child repository
+ * exists on disk and is a git repository at its own root. The registry only
+ * checks paths stay inside the project root; it never checks existence or
+ * git-ness, so a typo'd path (e.g. `frontned`) would otherwise build cleanly
+ * and silently produce "no problems found." No-op for single-repo projects.
+ */
+function checkWorkspaceRepositoryHealth(basePath, prefs, issues) {
+    if (prefs?.workspace?.mode !== "parent")
+        return;
+    let registry;
+    try {
+        registry = createRepositoryRegistryFromPreferences(basePath, prefs);
+    }
+    catch (err) {
+        issues.push({
+            severity: "error",
+            code: "invalid_preferences",
+            scope: "project",
+            unitId: "workspace",
+            message: `workspace registry failed to build: ${err instanceof Error ? err.message : String(err)}`,
+            fixable: false,
+        });
+        return;
+    }
+    for (const repo of registry.repositories) {
+        if (repo.id === "project")
+            continue;
+        if (!existsSync(repo.root)) {
+            issues.push({
+                severity: "error",
+                code: "workspace_repo_path_missing",
+                scope: "project",
+                unitId: `workspace.repositories.${repo.id}`,
+                message: `declared repository "${repo.id}" path does not exist on disk: ${repo.root}`,
+                fixable: false,
+            });
+            continue;
+        }
+        // Must be a repo at its OWN root — a plain dir nested in the parent repo
+        // would otherwise pass a bare `nativeIsRepo` check via the enclosing
+        // parent's .git. Compare on realpath so symlinked temp roots (macOS
+        // /var vs /private/var) don't cause a false mismatch.
+        const toplevel = resolveGitToplevel(repo.root);
+        const declaredReal = realpathSafe(repo.root);
+        const toplevelReal = toplevel ? realpathSafe(toplevel) : null;
+        if (toplevelReal !== declaredReal) {
+            issues.push({
+                severity: "warning",
+                code: "workspace_repo_not_a_repo",
+                scope: "project",
+                unitId: `workspace.repositories.${repo.id}`,
+                message: `declared repository "${repo.id}" path is not a git repository at its own root: ${repo.root}`,
+                fixable: false,
+            });
+        }
+    }
+}
 export async function runGSDDoctor(basePath, options) {
     const issues = [];
     const fixesApplied = [];
@@ -333,7 +424,8 @@ export async function runGSDDoctor(basePath, options) {
     const isolationMode = options?.isolationMode ??
         (prefs?.preferences?.git?.isolation === "worktree" ? "worktree" :
             prefs?.preferences?.git?.isolation === "branch" ? "branch" : "none");
-    await checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode);
+    await checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode, dryRun);
+    checkWorkspaceRepositoryHealth(basePath, prefs?.preferences, issues);
     const gitMs = Date.now() - t0git;
     // Runtime health checks — timed
     const t0runtime = Date.now();
@@ -350,9 +442,10 @@ export async function runGSDDoctor(basePath, options) {
     });
     const envMs = Date.now() - t0env;
     // Engine health checks — DB constraints and projection drift
-    await checkEngineHealth(basePath, issues, fixesApplied);
+    await checkEngineHealth(basePath, issues, fixesApplied, { repair: fix && !dryRun });
     const milestonesPath = milestonesDir(basePath);
-    if (!existsSync(milestonesPath)) {
+    const legacyMilestonesPath2 = legacyMilestonesDir(basePath);
+    if (!existsSync(milestonesPath) && !existsSync(legacyMilestonesPath2)) {
         const report = { ok: issues.every(i => i.severity !== "error"), basePath, issues, fixesApplied, timing: { git: gitMs, runtime: runtimeMs, environment: envMs, gsdState: 0 } };
         await appendDoctorHistory(basePath, report);
         return report;
@@ -396,7 +489,13 @@ export async function runGSDDoctor(basePath, options) {
             // Non-fatal — provider check failure should not block other checks
         }
     }
-    for (const milestone of state.registry) {
+    // When DB is unavailable, state.registry is empty. Fall back to a direct
+    // filesystem scan so the doctor can still report issues (e.g. missing ROADMAP)
+    // for milestone dirs that exist on disk.
+    const milestoneEntries = state.registry.length > 0
+        ? state.registry
+        : findMilestoneIds(basePath).map(id => ({ id, title: id }));
+    for (const milestone of milestoneEntries) {
         const milestoneId = milestone.id;
         const milestonePath = resolveMilestonePath(basePath, milestoneId);
         if (!milestonePath)
@@ -433,8 +532,17 @@ export async function runGSDDoctor(basePath, options) {
         }
         const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
         const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
-        if (!roadmapContent)
+        if (!roadmapContent) {
+            issues.push({
+                severity: "error",
+                code: "missing_roadmap",
+                scope: "milestone",
+                unitId: milestoneId,
+                message: `Milestone ${milestoneId} is missing its ROADMAP.md file.`,
+                fixable: false,
+            });
             continue;
+        }
         let slices;
         if (isDbAvailable()) {
             const dbSlices = getMilestoneSlices(milestoneId);
@@ -574,6 +682,9 @@ export async function runGSDDoctor(basePath, options) {
                 // Skipped slices may legitimately never create tasks/.
                 if (slice.pending || slice.skipped)
                     continue;
+                // Flat-phase: tasks are embedded in plan files; no tasks/ subdir expected.
+                if (!existsSync(legacyMilestonesDir(basePath)))
+                    continue;
                 issues.push({
                     severity: slice.done ? "warning" : "error",
                     code: "missing_tasks_dir",
@@ -739,7 +850,7 @@ export async function runGSDDoctor(basePath, options) {
                 code: "all_slices_done_missing_milestone_validation",
                 scope: "milestone",
                 unitId: milestoneId,
-                message: `All slices are done but ${milestoneId}-VALIDATION.md is missing \u2014 milestone is in validating-milestone phase`,
+                message: `All slices are done but the milestone VALIDATION.md is missing \u2014 milestone is in validating-milestone phase`,
                 file: relMilestoneFile(basePath, milestoneId, "VALIDATION"),
                 fixable: false,
             });

package/dist/resources/extensions/gsd/error-classifier.js

@@ -9,7 +9,7 @@
  *
  * @see https://github.com/open-gsd/gsd-pi/issues/2577
  */
-import { TOOL_SURFACE_NOT_READY } from "./tool-surface-readiness.js";
+import { TOOL_SURFACE_NOT_READY, isTerminalToolSurfaceError } from "./tool-surface-readiness.js";
 export function createRetryState() {
     return { networkRetryCount: 0, consecutiveTransientCount: 0, currentRetryModelId: undefined };
 }
@@ -82,7 +82,19 @@ export function classifyError(errorMsg, retryAfterMs) {
     if (TOOL_SCHEMA_RE.test(errorMsg)) {
         return { kind: "tool-schema", retryAfterMs: 0 };
     }
+    // Terminal tool-surface failure: the workflow MCP server is in a
+    // non-self-healing status (failed / needs-auth / disabled). This is NOT
+    // transient — retrying the same model cannot repair a dead server, so it
+    // must escalate / pause rather than retrying every ~3s into the per-unit
+    // cost cap. Checked ahead of the transient readiness branch below, which
+    // shares the TOOL_SURFACE_NOT_READY prefix and would otherwise collapse the
+    // terminal case into a transient `network` retry. See #783.
+    if (isTerminalToolSurfaceError(errorMsg)) {
+        return { kind: "permanent" };
+    }
     // Tool-surface readiness abort — transient; retry the same model shortly.
+    // This covers the not-yet-connected variants (absent, pending, connected but
+    // not registered); terminal statuses were handled by the branch above.
     if (TOOL_SURFACE_NOT_READY_RE.test(errorMsg)) {
         return { kind: "network", retryAfterMs: retryAfterMs ?? 3_000 };
     }

package/dist/resources/extensions/gsd/escalation.js

@@ -7,7 +7,7 @@
 // execute-task only (refine-slice escalation is deferred per ADR-011).
 import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { resolveSlicePath } from "./paths.js";
+import { legacyMilestonesDir, resolveSlicePath, resolveTasksDir } from "./paths.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { getTask, setTaskEscalationPending, setTaskEscalationAwaitingReview, clearTaskEscalationFlags, claimEscalationOverride, findUnappliedEscalationOverride, setTaskBlockerSource, listEscalationArtifacts, } from "./gsd-db.js";
 import { emitUokAuditEvent, buildAuditEnvelope } from "./uok/audit.js";
@@ -18,10 +18,17 @@ import { logWarning } from "./workflow-logger.js";
  *   .gsd/milestones/{M}/slices/{S}/tasks/{T}-ESCALATION.json
  */
 export function escalationArtifactPath(basePath, milestoneId, sliceId, taskId) {
-    const sDir = resolveSlicePath(basePath, milestoneId, sliceId);
-    if (!sDir)
+    const tDir = resolveTasksDir(basePath, milestoneId, sliceId);
+    if (tDir)
+        return join(tDir, `${taskId}-ESCALATION.json`);
+    // Flat-phase: tasks live in plan files; escalation artifacts sit in the phase dir.
+    // Legacy without tasks/: return null so writeEscalationArtifact throws (run doctor).
+    if (existsSync(legacyMilestonesDir(basePath)))
         return null;
-    return join(sDir, "tasks", `${taskId}-ESCALATION.json`);
+    const phaseDir = resolveSlicePath(basePath, milestoneId, sliceId);
+    if (!phaseDir)
+        return null;
+    return join(phaseDir, `${taskId}-ESCALATION.json`);
 }
 // ─── Artifact I/O ─────────────────────────────────────────────────────────
 /** Build an EscalationArtifact from a gsd_complete_task escalation payload. */

package/dist/resources/extensions/gsd/exec-sandbox.js

@@ -11,7 +11,8 @@ import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { resolve } from "node:path";
-import { killProcessTree, SIGKILL_GRACE_MS, HARD_DEADLINE_MS } from "@gsd/pi-coding-agent";
+import { getShellConfig, killProcessTree, SIGKILL_GRACE_MS, HARD_DEADLINE_MS } from "@gsd/pi-coding-agent";
+import { redactSecrets } from "./redact-secrets.js";
 const ALWAYS_FORWARD_ENV = ["PATH", "HOME"];
 // SIGKILL_GRACE_MS / HARD_DEADLINE_MS are imported from @gsd/pi-coding-agent
 // (shell.ts) — the single source of truth for the graceful-kill timing ladder —
@@ -60,7 +61,13 @@ function clampTimeout(request, opts) {
 function resolveCommand(runtime) {
     switch (runtime) {
         case "bash":
-            return { cmd: "bash", args: ["-c"] };
+            try {
+                const { shell, args } = getShellConfig();
+                return { cmd: shell, args };
+            }
+            catch {
+                return { cmd: "bash", args: ["-c"] };
+            }
         case "node":
             return { cmd: process.execPath, args: ["-e"] };
         case "python":
@@ -180,10 +187,22 @@ export function runExecSandbox(request, opts) {
         const effectiveGraceMs = opts.kill_grace_ms ?? SIGKILL_GRACE_MS;
         const effectiveForceResolveDelay = opts.force_resolve_delay_ms ?? (effectiveGraceMs + HARD_DEADLINE_MS);
         let timedOut = false;
+        let aborted = false;
         let settled = false;
+        let killInitiated = false;
+        let timer;
         let forceResolveTimer;
-        const timer = setTimeout(() => {
-            timedOut = true;
+        let abortListener;
+        const removeAbortListener = () => {
+            if (opts.signal && abortListener) {
+                opts.signal.removeEventListener("abort", abortListener);
+                abortListener = undefined;
+            }
+        };
+        const initiateKill = () => {
+            if (killInitiated)
+                return;
+            killInitiated = true;
             // killProcessTree handles both platforms and kills the whole tree: on Unix
             // it signals the process group (SIGTERM -> grace -> SIGKILL); on Windows it
             // force-kills the tree via taskkill /F /T. Using child.kill("SIGTERM") here
@@ -201,35 +220,41 @@ export function runExecSandbox(request, opts) {
                 finalize(null, "SIGKILL", true);
             }, effectiveForceResolveDelay);
             forceResolveTimer.unref?.();
-        }, timeoutMs);
-        timer.unref?.();
+        };
         const finalize = (exitCode, signal, forceResolved = false) => {
             if (settled)
                 return;
             settled = true;
             clearTimeout(timer);
             clearTimeout(forceResolveTimer);
+            removeAbortListener();
             const duration = Date.now() - started;
             const stdoutBuf = Buffer.concat(stdoutChunks);
             const stderrBuf = Buffer.concat(stderrChunks);
             const stdoutSuffix = stdoutTruncated ? "\n[truncated: stdout cap reached]\n" : "";
             const stderrSuffix = stderrTruncated ? "\n[truncated: stderr cap reached]\n" : "";
-            writeFileSync(stdoutPath, Buffer.concat([stdoutBuf, Buffer.from(stdoutSuffix, "utf-8")]));
-            writeFileSync(stderrPath, Buffer.concat([stderrBuf, Buffer.from(stderrSuffix, "utf-8")]));
+            // Redact secret-shaped substrings before persisting to .gsd/exec/ (skipped by
+            // the secret scanner). The returned digest is derived from the raw buffer
+            // below and is redacted downstream when the session is written to activity/.
+            writeFileSync(stdoutPath, redactSecrets(Buffer.concat([stdoutBuf, Buffer.from(stdoutSuffix, "utf-8")]).toString("utf-8")));
+            writeFileSync(stderrPath, redactSecrets(Buffer.concat([stderrBuf, Buffer.from(stderrSuffix, "utf-8")]).toString("utf-8")));
             const digestBody = tail(stdoutBuf, opts.digest_chars);
             const digest = digestBody.length > 0
                 ? digestBody
-                : timedOut
-                    ? "[no stdout — timed out]"
-                    : stderrBuf.length > 0
-                        ? `[no stdout — tail of stderr]\n${tail(stderrBuf, opts.digest_chars)}`
-                        : "[no output]";
+                : aborted
+                    ? "[no stdout — aborted]"
+                    : timedOut
+                        ? "[no stdout — timed out]"
+                        : stderrBuf.length > 0
+                            ? `[no stdout — tail of stderr]\n${tail(stderrBuf, opts.digest_chars)}`
+                            : "[no output]";
             const result = {
                 id,
                 runtime: request.runtime,
                 exit_code: exitCode,
                 signal,
                 timed_out: timedOut,
+                aborted,
                 force_resolved: forceResolved,
                 duration_ms: duration,
                 stdout_bytes: stdoutBytes,
@@ -244,6 +269,26 @@ export function runExecSandbox(request, opts) {
             writeMeta(metaPath, result, request, now);
             resolveP(result);
         };
+        timer = setTimeout(() => {
+            timedOut = true;
+            initiateKill();
+        }, timeoutMs);
+        timer.unref?.();
+        if (opts.signal) {
+            abortListener = () => {
+                if (settled || timedOut)
+                    return;
+                aborted = true;
+                clearTimeout(timer);
+                initiateKill();
+            };
+            if (opts.signal.aborted) {
+                abortListener();
+            }
+            else {
+                opts.signal.addEventListener("abort", abortListener, { once: true });
+            }
+        }
         child.on("error", (err) => {
             const message = err instanceof Error ? err.message : String(err);
             const line = `child error: ${message}\n`;
@@ -274,6 +319,7 @@ function writeMeta(path, result, request, now) {
         exit_code: result.exit_code,
         signal: result.signal,
         timed_out: result.timed_out,
+        aborted: result.aborted === true,
         force_resolved: result.force_resolved,
         duration_ms: result.duration_ms,
         stdout_bytes: result.stdout_bytes,

package/dist/resources/extensions/gsd/export-html.js

@@ -760,10 +760,11 @@ function buildChangelogSection(data) {
 // ─── Section: Knowledge ───────────────────────────────────────────────────────
 function buildKnowledgeSection(data) {
     const k = data.knowledge;
-    if (!k.exists)
+    const memories = data.memories;
+    if (!k.exists && memories.entries.length === 0)
         return section('knowledge', 'Knowledge', '<p class="empty">No KNOWLEDGE.md found.</p>');
     const total = k.rules.length + k.patterns.length + k.lessons.length;
-    if (total === 0)
+    if (total === 0 && memories.entries.length === 0)
         return section('knowledge', 'Knowledge', '<p class="empty">KNOWLEDGE.md exists but no entries parsed.</p>');
     const rulesHtml = k.rules.length > 0 ? `
     <h3>Rules <span class="count">${k.rules.length}</span></h3>
@@ -783,7 +784,13 @@ function buildKnowledgeSection(data) {
       <thead><tr><th>ID</th><th>Lesson</th></tr></thead>
       <tbody>${k.lessons.map(l => `<tr><td class="mono">${esc(l.id)}</td><td>${esc(l.content)}</td></tr>`).join('')}</tbody>
     </table>` : '';
-    return section('knowledge', `Knowledge <span class="count">${total}</span>`, `${rulesHtml}${patternsHtml}${lessonsHtml}`);
+    const memoriesHtml = memories.entries.length > 0 ? `
+    <h3>Memories <span class="count">${memories.entries.length}/${memories.totalCount}</span></h3>
+    <table class="tbl">
+      <thead><tr><th>ID</th><th>Category</th><th>Scope</th><th>Memory</th></tr></thead>
+      <tbody>${memories.entries.map(m => `<tr><td class="mono">${esc(m.id)}</td><td>${esc(m.category)}</td><td>${esc(m.scope)}</td><td>${esc(m.content)}</td></tr>`).join('')}</tbody>
+    </table>` : '';
+    return section('knowledge', `Knowledge <span class="count">${total + memories.totalCount}</span>`, `${rulesHtml}${patternsHtml}${lessonsHtml}${memoriesHtml}`);
 }
 // ─── Section: Captures ────────────────────────────────────────────────────────
 function buildCapturesSection(data) {

package/dist/resources/extensions/gsd/export.js

@@ -7,6 +7,71 @@ import { getLedger, getProjectTotals, aggregateByPhase, aggregateBySlice, aggreg
 import { gsdRoot } from "./paths.js";
 import { formatDuration, fileLink } from "../shared/format-utils.js";
 import { getErrorMessage } from "./error-utils.js";
+import { isDbAvailable } from "./gsd-db.js";
+import { openExistingWorkflowDatabase } from "./db-workspace.js";
+import { getActiveMemories, getActiveMemoriesRanked } from "./memory-store.js";
+const EXPORT_MEMORY_LIMIT = 20;
+const EXPORT_MEMORY_CONTENT_LIMIT = 2000;
+function ensureExportDb(basePath) {
+    if (isDbAvailable())
+        return;
+    openExistingWorkflowDatabase(basePath);
+}
+function loadExportMemories(basePath, visualizerData) {
+    if (visualizerData?.memories)
+        return limitMemoryInfo(visualizerData.memories);
+    ensureExportDb(basePath);
+    try {
+        const allActive = getActiveMemories();
+        const ranked = getActiveMemoriesRanked(EXPORT_MEMORY_LIMIT);
+        return {
+            totalCount: allActive.length,
+            entries: ranked.map((memory) => ({
+                id: memory.id,
+                category: memory.category,
+                content: limitMemoryContent(memory.content),
+                confidence: memory.confidence,
+                hitCount: memory.hit_count,
+                scope: memory.scope,
+                tags: memory.tags,
+                updatedAt: memory.updated_at,
+            })),
+        };
+    }
+    catch {
+        return { entries: [], totalCount: 0 };
+    }
+}
+function limitMemoryInfo(memories) {
+    return {
+        totalCount: memories.totalCount,
+        entries: memories.entries.map((memory) => ({
+            ...memory,
+            content: limitMemoryContent(memory.content),
+        })),
+    };
+}
+function limitMemoryContent(content) {
+    if (content.length <= EXPORT_MEMORY_CONTENT_LIMIT)
+        return content;
+    return `${content.slice(0, EXPORT_MEMORY_CONTENT_LIMIT).trimEnd()}...`;
+}
+function formatMemoryLines(memories) {
+    if (memories.entries.length === 0)
+        return [];
+    return [
+        `## Memories`,
+        ``,
+        `Active memories: ${memories.totalCount}`,
+        ``,
+        ...memories.entries.map((memory) => {
+            const scope = memory.scope ? `, scope ${memory.scope}` : "";
+            const tags = memory.tags.length > 0 ? `, tags ${memory.tags.join(", ")}` : "";
+            return `- **${memory.id}** (${memory.category}, confidence ${Math.round(memory.confidence * 100)}%, hits ${memory.hitCount}${scope}${tags}): ${memory.content}`;
+        }),
+        ``,
+    ];
+}
 /**
  * Open a file in the user's default browser.
  * Uses platform-specific commands: `open` (macOS), `xdg-open` (Linux), `start` (Windows).
@@ -47,6 +112,7 @@ export function writeExportFile(basePath, format, visualizerData) {
     mkdirSync(exportDir, { recursive: true });
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
     if (format === "json") {
+        const memories = loadExportMemories(basePath, visualizerData);
         const report = {
             exportedAt: new Date().toISOString(),
             project: projectName,
@@ -54,6 +120,7 @@ export function writeExportFile(basePath, format, visualizerData) {
             byPhase: visualizerData?.byPhase ?? aggregateByPhase(units),
             bySlice: visualizerData?.bySlice ?? aggregateBySlice(units),
             byModel: visualizerData?.byModel ?? aggregateByModel(units),
+            memories,
             units,
         };
         const outPath = join(exportDir, `export-${timestamp}.json`);
@@ -64,6 +131,7 @@ export function writeExportFile(basePath, format, visualizerData) {
         const totals = visualizerData?.totals ?? getProjectTotals(units);
         const phases = visualizerData?.byPhase ?? aggregateByPhase(units);
         const slices = visualizerData?.bySlice ?? aggregateBySlice(units);
+        const memories = loadExportMemories(basePath, visualizerData);
         const md = [
             `# GSD Session Report — ${projectName}`,
             ``,
@@ -86,6 +154,7 @@ export function writeExportFile(basePath, format, visualizerData) {
             `|-------|-------|------|--------|----------|`,
             ...slices.map((s) => `| ${s.sliceId} | ${s.units} | ${formatCost(s.cost)} | ${formatTokenCount(s.tokens.total)} | ${formatDuration(s.duration)} |`),
             ``,
+            ...formatMemoryLines(memories),
         ].join("\n");
         const outPath = join(exportDir, `export-${timestamp}.md`);
         writeFileSync(outPath, md, "utf-8");
@@ -216,6 +285,7 @@ export async function handleExport(args, ctx, basePath) {
     mkdirSync(exportDir, { recursive: true });
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
     if (format === "json") {
+        const memories = loadExportMemories(basePath);
         const report = {
             exportedAt: new Date().toISOString(),
             project: projectName,
@@ -223,6 +293,7 @@ export async function handleExport(args, ctx, basePath) {
             byPhase: aggregateByPhase(units),
             bySlice: aggregateBySlice(units),
             byModel: aggregateByModel(units),
+            memories,
             units,
         };
         const outPath = join(exportDir, `export-${timestamp}.json`);
@@ -233,6 +304,7 @@ export async function handleExport(args, ctx, basePath) {
         const totals = getProjectTotals(units);
         const phases = aggregateByPhase(units);
         const slices = aggregateBySlice(units);
+        const memories = loadExportMemories(basePath);
         const md = [
             `# GSD Session Report — ${projectName}`,
             ``,
@@ -255,6 +327,7 @@ export async function handleExport(args, ctx, basePath) {
             `|-------|-------|------|--------|----------|`,
             ...slices.map(s => `| ${s.sliceId} | ${s.units} | ${formatCost(s.cost)} | ${formatTokenCount(s.tokens.total)} | ${formatDuration(s.duration)} |`),
             ``,
+            ...formatMemoryLines(memories),
             `## Unit History`,
             ``,
             `| Type | ID | Model | Cost | Tokens | Duration |`,

package/dist/resources/extensions/gsd/file-lock.js

@@ -30,9 +30,9 @@ function acquireLockSyncWithRetry(filePath, retries, stale) {
 export function withFileLockSync(filePath, fn, opts = {}) {
     if (!existsSync(filePath))
         return fn();
-    const retries = opts.retries ?? DEFAULT_RETRIES;
     const stale = opts.stale ?? DEFAULT_STALE_MS;
     const onLocked = opts.onLocked ?? "fail";
+    const retries = onLocked === "skip" ? 0 : (opts.retries ?? DEFAULT_RETRIES);
     try {
         const release = acquireLockSyncWithRetry(filePath, retries, stale);
         try {