gsd-pi 2.75.0-dev.b6ad8c5f7 → 2.75.0-dev.e41b70b10

package/dist/resources/extensions/gsd/auto/phases.js

@@ -607,6 +607,8 @@ export async function runDispatch(ic, preData, loopState) {
         prefs,
         session: s,
         structuredQuestionsAvailable,
+        sessionContextWindow: ctx.model?.contextWindow,
+        modelRegistry: ctx.modelRegistry,
     });
     if (dispatchResult.action === "stop") {
         deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "dispatch-stop", rule: dispatchResult.matchedRule, data: { reason: dispatchResult.reason } });

package/dist/resources/extensions/gsd/auto-dashboard.js

@@ -9,6 +9,7 @@ import { getCurrentBranch } from "./worktree.js";
 import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { getErrorMessage } from "./error-utils.js";
+import { nativeIsRepo } from "./native-git-bridge.js";
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { execFileSync } from "node:child_process";
@@ -256,6 +257,10 @@ let cachedLastCommit = null;
 let lastCommitFetchedAt = 0;
 function refreshLastCommit(basePath) {
     try {
+        if (!nativeIsRepo(basePath)) {
+            cachedLastCommit = null;
+            return;
+        }
         const raw = execFileSync("git", ["log", "-1", "--format=%cr|%s"], {
             cwd: basePath,
             encoding: "utf-8",
@@ -269,12 +274,15 @@ function refreshLastCommit(basePath) {
                 message: raw.slice(sep + 1),
             };
         }
-        lastCommitFetchedAt = Date.now();
     }
     catch (err) {
         // Non-fatal — just skip last commit display
+        cachedLastCommit = null;
         logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
     }
+    finally {
+        lastCommitFetchedAt = Date.now();
+    }
 }
 function getLastCommit(basePath) {
     // Refresh at most every 15 seconds
@@ -283,6 +291,19 @@ function getLastCommit(basePath) {
     }
     return cachedLastCommit;
 }
+export function _resetLastCommitCacheForTests() {
+    cachedLastCommit = null;
+    lastCommitFetchedAt = 0;
+}
+export function _refreshLastCommitForTests(basePath) {
+    refreshLastCommit(basePath);
+}
+export function _getLastCommitForTests(basePath) {
+    return getLastCommit(basePath);
+}
+export function _getLastCommitFetchedAtForTests() {
+    return lastCommitFetchedAt;
+}
 // ─── Footer Factory ───────────────────────────────────────────────────────────
 /**
  * Footer factory used by auto-mode.

package/dist/resources/extensions/gsd/auto-direct-dispatch.js

@@ -68,7 +68,10 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
                 }
                 unitType = "plan-slice";
                 unitId = `${mid}/${sid}`;
-                prompt = await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, base);
+                prompt = await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, base, undefined, {
+                    sessionContextWindow: ctx.model?.contextWindow,
+                    modelRegistry: ctx.modelRegistry,
+                });
             }
             else {
                 unitType = "plan-milestone";
@@ -93,7 +96,10 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             }
             unitType = "execute-task";
             unitId = `${mid}/${sid}/${tid}`;
-            prompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base);
+            prompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, {
+                sessionContextWindow: ctx.model?.contextWindow,
+                modelRegistry: ctx.modelRegistry,
+            });
             break;
         }
         case "complete":

package/dist/resources/extensions/gsd/auto-dispatch.js

@@ -412,7 +412,7 @@ export const DISPATCH_RULES = [
         // auto-heal without either adding an explicit `setSliceSketchFlag(..., false)`
         // call here or doing so inside the plan-slice tool handler.
         name: "refining → refine-slice",
-        match: async ({ state, mid, midTitle, basePath, prefs }) => {
+        match: async ({ state, mid, midTitle, basePath, prefs, sessionContextWindow, modelRegistry }) => {
             if (state.phase !== "refining")
                 return null;
             if (!state.activeSlice)
@@ -438,20 +438,20 @@ export const DISPATCH_RULES = [
                     action: "dispatch",
                     unitType: "plan-slice",
                     unitId: `${mid}/${sid}`,
-                    prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, softScopeHint ? { softScopeHint } : undefined),
+                    prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { ...(softScopeHint ? { softScopeHint } : {}), sessionContextWindow, modelRegistry }),
                 };
             }
             return {
                 action: "dispatch",
                 unitType: "refine-slice",
                 unitId: `${mid}/${sid}`,
-                prompt: await buildRefineSlicePrompt(mid, midTitle, sid, sTitle, basePath),
+                prompt: await buildRefineSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry }),
             };
         },
     },
     {
         name: "planning → plan-slice",
-        match: async ({ state, mid, midTitle, basePath }) => {
+        match: async ({ state, mid, midTitle, basePath, sessionContextWindow, modelRegistry }) => {
             if (state.phase !== "planning")
                 return null;
             if (!state.activeSlice)
@@ -462,7 +462,7 @@ export const DISPATCH_RULES = [
                 action: "dispatch",
                 unitType: "plan-slice",
                 unitId: `${mid}/${sid}`,
-                prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath),
+                prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry }),
             };
         },
     },
@@ -511,7 +511,7 @@ export const DISPATCH_RULES = [
     },
     {
         name: "executing → reactive-execute (parallel dispatch)",
-        match: async ({ state, mid, midTitle, basePath, prefs }) => {
+        match: async ({ state, mid, midTitle, basePath, prefs, sessionContextWindow, modelRegistry }) => {
             if (state.phase !== "executing" || !state.activeTask)
                 return null;
             if (!state.activeSlice)
@@ -574,7 +574,7 @@ export const DISPATCH_RULES = [
                     action: "dispatch",
                     unitType: "reactive-execute",
                     unitId: `${mid}/${sid}/reactive+${batchSuffix}`,
-                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath, subagentModel),
+                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath, subagentModel, { sessionContextWindow, modelRegistry }),
                 };
             }
             catch (err) {
@@ -586,7 +586,7 @@ export const DISPATCH_RULES = [
     },
     {
         name: "executing → execute-task (recover missing task plan → plan-slice)",
-        match: async ({ state, mid, midTitle, basePath }) => {
+        match: async ({ state, mid, midTitle, basePath, sessionContextWindow, modelRegistry }) => {
             if (state.phase !== "executing" || !state.activeTask)
                 return null;
             if (!state.activeSlice)
@@ -605,7 +605,7 @@ export const DISPATCH_RULES = [
                     action: "dispatch",
                     unitType: "plan-slice",
                     unitId: `${mid}/${sid}`,
-                    prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath),
+                    prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry }),
                 };
             }
             return null;
@@ -613,7 +613,7 @@ export const DISPATCH_RULES = [
     },
     {
         name: "executing → execute-task",
-        match: async ({ state, mid, basePath }) => {
+        match: async ({ state, mid, basePath, sessionContextWindow, modelRegistry }) => {
             if (state.phase !== "executing" || !state.activeTask)
                 return null;
             if (!state.activeSlice)
@@ -626,7 +626,7 @@ export const DISPATCH_RULES = [
                 action: "dispatch",
                 unitType: "execute-task",
                 unitId: `${mid}/${sid}/${tid}`,
-                prompt: await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, basePath),
+                prompt: await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, basePath, { sessionContextWindow, modelRegistry }),
             };
         },
     },

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -382,7 +382,9 @@ export function resolveModelId(modelId, availableModels, currentProvider) {
         if (providerMatch)
             return providerMatch;
     }
-    // Prefer "anthropic" as the canonical provider for Anthropic models
+    // Prefer "anthropic" as the canonical provider for Anthropic models.
+    // Transport-specific tiebreaker (ADR-012): intentionally keys on provider,
+    // not api — we want the plain Anthropic transport when multiple are available.
     const anthropicMatch = candidates.find(m => m.provider === "anthropic");
     if (anthropicMatch)
         return anthropicMatch;

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -75,15 +75,17 @@ function capPreamble(preamble) {
  * Uses the budget engine to compute task count ranges and inline context budgets
  * based on the configured executor model's context window.
  */
-function formatExecutorConstraints() {
+function formatExecutorConstraints(sessionContextWindow, modelRegistry) {
     let windowTokens;
     try {
         const prefs = loadEffectiveGSDPreferences();
-        windowTokens = resolveExecutorContextWindow(undefined, prefs?.preferences);
+        windowTokens = resolveExecutorContextWindow(modelRegistry, prefs?.preferences, sessionContextWindow);
     }
     catch (e) {
         logWarning("prompt", `resolveExecutorContextWindow failed: ${e.message}`);
-        windowTokens = 200_000; // safe default
+        // Delegate to the budget engine without prefs (the path that just threw)
+        // so DEFAULT_CONTEXT_WINDOW stays the single source of truth.
+        windowTokens = resolveExecutorContextWindow(undefined, undefined, sessionContextWindow);
     }
     const budgets = computeBudgets(windowTokens);
     const { min, max } = budgets.taskCountRange;
@@ -1136,7 +1138,7 @@ export async function buildResearchSlicePrompt(mid, _midTitle, sid, sTitle, base
  * sketch-scope constraint).
  */
 async function renderSlicePrompt(options) {
-    const { mid, sid, sTitle, base, level, promptTemplate, prependBlocks = [], extraVars = {} } = options;
+    const { mid, sid, sTitle, base, level, promptTemplate, prependBlocks = [], extraVars = {}, sessionContextWindow, modelRegistry, } = options;
     const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
     const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
     const researchPath = resolveSliceFile(base, mid, sid, "RESEARCH");
@@ -1186,7 +1188,7 @@ async function renderSlicePrompt(options) {
     if (overridesInline)
         inlined.unshift(overridesInline);
     const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
-    const executorContextConstraints = formatExecutorConstraints();
+    const executorContextConstraints = formatExecutorConstraints(sessionContextWindow, modelRegistry);
     const outputRelPath = relSliceFile(base, mid, sid, "PLAN");
     const commitInstruction = "Do not commit — .gsd/ planning docs are managed externally and not tracked in git.";
     return loadPrompt(promptTemplate, {
@@ -1226,6 +1228,8 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
         level: level ?? resolveInlineLevel(),
         promptTemplate: "plan-slice",
         prependBlocks,
+        sessionContextWindow: options?.sessionContextWindow,
+        modelRegistry: options?.modelRegistry,
     });
 }
 /**
@@ -1235,7 +1239,7 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
  * blank-sheet planning pass. Reuses inlineDependencySummaries for prior
  * slice SUMMARY and inlines the stored sketch_scope as a hard constraint.
  */
-export async function buildRefineSlicePrompt(mid, _midTitle, sid, sTitle, base, level) {
+export async function buildRefineSlicePrompt(mid, _midTitle, sid, sTitle, base, level, options) {
     // Pull the stored sketch scope from the DB — the hard constraint we plan within.
     let sketchScope = "";
     try {
@@ -1258,6 +1262,8 @@ export async function buildRefineSlicePrompt(mid, _midTitle, sid, sTitle, base,
         promptTemplate: "refine-slice",
         prependBlocks,
         extraVars: { sketchScope },
+        sessionContextWindow: options?.sessionContextWindow,
+        modelRegistry: options?.modelRegistry,
     });
 }
 export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, level) {
@@ -1323,7 +1329,7 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     const overridesSection = formatOverridesSection(activeOverrides);
     // Compute verification budget for the executor's context window (issue #707)
     const prefs = loadEffectiveGSDPreferences();
-    const contextWindow = resolveExecutorContextWindow(undefined, prefs?.preferences);
+    const contextWindow = resolveExecutorContextWindow(opts.modelRegistry, prefs?.preferences, opts.sessionContextWindow);
     const budgets = computeBudgets(contextWindow);
     const verificationBudget = `~${Math.round(budgets.verificationBudgetChars / 1000)}K chars`;
     // Truncate carry-forward section when it exceeds 40% of inline context budget.
@@ -1858,7 +1864,7 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
     });
 }
 // ─── Reactive Execute Prompt ──────────────────────────────────────────────
-export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, readyTaskIds, base, subagentModel) {
+export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, readyTaskIds, base, subagentModel, opts) {
     const { loadSliceTaskIO, deriveTaskGraph, graphMetrics } = await import("./reactive-graph.js");
     // Build graph for context
     const taskIO = await loadSliceTaskIO(base, mid, sid);
@@ -1889,7 +1895,11 @@ export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, rea
         // Build dependency-scoped carry-forward paths for this task
         const depPaths = await getDependencyTaskSummaryPaths(mid, sid, tid, node?.dependsOn ?? [], base);
         // Build a full execute-task prompt with dependency-based carry-forward
-        const taskPrompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, { carryForwardPaths: depPaths });
+        const taskPrompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, {
+            carryForwardPaths: depPaths,
+            sessionContextWindow: opts?.sessionContextWindow,
+            modelRegistry: opts?.modelRegistry,
+        });
         const modelSuffix = subagentModel ? ` with model: "${subagentModel}"` : "";
         subagentSections.push([
             `### ${tid}: ${tTitle}`,

package/dist/resources/extensions/gsd/auto-worktree.js

@@ -180,6 +180,14 @@ function clearProjectRootStateFiles(basePath, milestoneId) {
         }
     }
 }
+function isProjectGsdSymlink(basePath) {
+    try {
+        return lstatSyncFn(join(basePath, ".gsd")).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
 // ─── Build Artifact Auto-Resolve ─────────────────────────────────────────────
 /** Patterns for machine-generated build artifacts that can be safely
  * auto-resolved by accepting --theirs during merge. These files are
@@ -1440,10 +1448,17 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             // CONTEXT files into the stash. If stash pop later fails, those files
             // are permanently trapped in the stash entry and lost on the next
             // stash push or drop.
+            //
+            // When `.gsd` itself is a symlink, Git rejects pathspecs below it
+            // ("beyond a symbolic link"). In that layout, exclude the whole symlink
+            // and keep stashing real project files that could block the merge.
+            const stashPathspecs = isProjectGsdSymlink(originalBasePath_)
+                ? [".", ":(exclude).gsd"]
+                : [":(exclude).gsd/milestones"];
             execFileSync("git", [
                 "stash", "push", "--include-untracked",
                 "-m", `gsd: pre-merge stash for ${milestoneId}`,
-                "--", ":(exclude).gsd/milestones",
+                "--", ...stashPathspecs,
             ], { cwd: originalBasePath_, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" });
             stashed = true;
         }

package/dist/resources/extensions/gsd/bootstrap/memory-tools.js

@@ -0,0 +1,128 @@
+// GSD2 — Memory tool registration
+//
+// Exposes the memory-layer tools (capture_thought, memory_query, gsd_graph)
+// to the LLM over MCP. All three degrade gracefully when the GSD database
+// is unavailable.
+import { Type } from "@sinclair/typebox";
+import { ensureDbOpen } from "./dynamic-tools.js";
+import { executeGsdGraph, executeMemoryCapture, executeMemoryQuery, } from "../tools/memory-tools.js";
+export function registerMemoryTools(pi) {
+    // ─── capture_thought ────────────────────────────────────────────────────
+    pi.registerTool({
+        name: "capture_thought",
+        label: "Capture Thought",
+        description: "Record a durable piece of project knowledge (decision, convention, gotcha, pattern, " +
+            "preference, or environment detail) into the GSD memory store. Use sparingly — one memory " +
+            "per genuinely reusable insight, not per task.",
+        promptSnippet: "Capture a durable project insight into the GSD memory store (categories: architecture, convention, gotcha, pattern, preference, environment)",
+        promptGuidelines: [
+            "Use capture_thought for insights that will remain useful across future sessions.",
+            "Do NOT capture one-off bug fixes, temporary state, secrets, or task-specific details.",
+            "Keep content to 1–3 sentences.",
+            "Set confidence: 0.6 tentative, 0.8 solid, 0.95 well-confirmed (default 0.8).",
+        ],
+        parameters: Type.Object({
+            category: Type.Union([
+                Type.Literal("architecture"),
+                Type.Literal("convention"),
+                Type.Literal("gotcha"),
+                Type.Literal("preference"),
+                Type.Literal("environment"),
+                Type.Literal("pattern"),
+            ], { description: "Memory category" }),
+            content: Type.String({ description: "The memory text (1–3 sentences, no secrets)" }),
+            confidence: Type.Optional(Type.Number({ description: "0.1–0.99, default 0.8", minimum: 0.1, maximum: 0.99 })),
+            tags: Type.Optional(Type.Array(Type.String(), { description: "Free-form tags (reserved for future use)" })),
+            scope: Type.Optional(Type.String({ description: "Scope name (reserved for future use; defaults to project)" })),
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            const ok = await ensureDbOpen();
+            if (!ok) {
+                return {
+                    content: [{ type: "text", text: "Error: GSD database is not available. Cannot capture memory." }],
+                    details: { operation: "memory_capture", error: "db_unavailable" },
+                    isError: true,
+                };
+            }
+            return executeMemoryCapture(params);
+        },
+    });
+    // ─── memory_query ───────────────────────────────────────────────────────
+    pi.registerTool({
+        name: "memory_query",
+        label: "Query Memory",
+        description: "Search the GSD memory store for relevant memories. Phase 1 uses keyword matching ranked " +
+            "by confidence and reinforcement; future phases add semantic (embedding) retrieval.",
+        promptSnippet: "Search the GSD memory store by keyword; returns ranked memories with id, category, and content",
+        promptGuidelines: [
+            "Use memory_query when you need durable project context that may not be in the current prompt.",
+            "Provide a short keyword-style query — not a full question.",
+            "Use category to narrow results to gotchas, conventions, architecture notes, etc.",
+        ],
+        parameters: Type.Object({
+            query: Type.String({ description: "Keyword query (2+ char terms)" }),
+            k: Type.Optional(Type.Number({ description: "Max results (default 10, max 50)", minimum: 1, maximum: 50 })),
+            category: Type.Optional(Type.Union([
+                Type.Literal("architecture"),
+                Type.Literal("convention"),
+                Type.Literal("gotcha"),
+                Type.Literal("preference"),
+                Type.Literal("environment"),
+                Type.Literal("pattern"),
+            ], { description: "Restrict results to a single category" })),
+            scope: Type.Optional(Type.String({ description: "Only include memories with this scope (e.g. 'project', 'global')" })),
+            tag: Type.Optional(Type.String({ description: "Only include memories tagged with this value" })),
+            include_superseded: Type.Optional(Type.Boolean({ description: "Include superseded memories (default false)" })),
+            reinforce_hits: Type.Optional(Type.Boolean({ description: "Increment hit_count on returned memories (default false)" })),
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            const ok = await ensureDbOpen();
+            if (!ok) {
+                return {
+                    content: [{ type: "text", text: "Error: GSD database is not available. Cannot query memory." }],
+                    details: { operation: "memory_query", error: "db_unavailable" },
+                    isError: true,
+                };
+            }
+            return executeMemoryQuery(params);
+        },
+    });
+    // ─── gsd_graph ──────────────────────────────────────────────────────────
+    pi.registerTool({
+        name: "gsd_graph",
+        label: "GSD Knowledge Graph",
+        description: "Inspect the relationship graph between memories. mode=query walks supersedes edges from a " +
+            "given memoryId; mode=build is a placeholder that future phases will use to rebuild graph " +
+            "edges from milestone LEARNINGS artifacts.",
+        promptSnippet: "Query the memory relationship graph or trigger a rebuild",
+        promptGuidelines: [
+            "Use mode=query with a memoryId when you want to see how a memory relates to others.",
+            "Phase 1 only exposes supersedes edges; additional relation types arrive in later phases.",
+        ],
+        parameters: Type.Object({
+            mode: Type.Union([Type.Literal("build"), Type.Literal("query")], {
+                description: "build = recompute graph (placeholder), query = inspect edges",
+            }),
+            memoryId: Type.Optional(Type.String({ description: "Memory ID (required when mode=query)" })),
+            depth: Type.Optional(Type.Number({ description: "Hops to traverse (0–5, default 1)", minimum: 0, maximum: 5 })),
+            rel: Type.Optional(Type.Union([
+                Type.Literal("related_to"),
+                Type.Literal("depends_on"),
+                Type.Literal("contradicts"),
+                Type.Literal("elaborates"),
+                Type.Literal("supersedes"),
+            ], { description: "Only include edges with this relation type" })),
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            const ok = await ensureDbOpen();
+            if (!ok) {
+                return {
+                    content: [{ type: "text", text: "Error: GSD database is not available." }],
+                    details: { operation: "gsd_graph", error: "db_unavailable" },
+                    isError: true,
+                };
+            }
+            return executeGsdGraph(params);
+        },
+    });
+}

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -5,6 +5,7 @@ import { loadEcosystemExtensions } from "../ecosystem/loader.js";
 import { registerDbTools } from "./db-tools.js";
 import { registerDynamicTools } from "./dynamic-tools.js";
 import { registerJournalTools } from "./journal-tools.js";
+import { registerMemoryTools } from "./memory-tools.js";
 import { registerQueryTools } from "./query-tools.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
@@ -74,6 +75,7 @@ export function registerGsdExtension(pi) {
         ["db-tools", () => registerDbTools(pi)],
         ["journal-tools", () => registerJournalTools(pi)],
         ["query-tools", () => registerQueryTools(pi)],
+        ["memory-tools", () => registerMemoryTools(pi)],
         ["shortcuts", () => registerShortcuts(pi)],
         ["hooks", () => registerHooks(pi, ecosystemHandlers)],
         ["ecosystem", () => {

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -89,10 +89,23 @@ export async function buildBeforeAgentStartResult(event, ctx) {
     }
     let memoryBlock = "";
     try {
-        const { formatMemoriesForPrompt, getActiveMemoriesRanked } = await import("../memory-store.js");
-        const memories = getActiveMemoriesRanked(30);
-        if (memories.length > 0) {
-            const formatted = formatMemoriesForPrompt(memories, 2000);
+        const { formatMemoriesForPrompt, getActiveMemoriesRanked, queryMemoriesRanked } = await import("../memory-store.js");
+        // Always-on "critical" set — small, stable memories that belong in every
+        // turn (gotchas, environment, conventions). Ranked by the existing score.
+        const CRITICAL_CATEGORIES = new Set(["gotcha", "environment", "convention"]);
+        const allRanked = getActiveMemoriesRanked(60);
+        const critical = allRanked.filter((m) => CRITICAL_CATEGORIES.has(m.category)).slice(0, 5);
+        const criticalIds = new Set(critical.map((m) => m.id));
+        // Prompt-relevance set — hybrid FTS5 + (future) semantic retrieval.
+        let relevant = [];
+        const userPrompt = (event.prompt ?? "").trim();
+        if (userPrompt) {
+            const hits = queryMemoriesRanked({ query: userPrompt, k: 10 });
+            relevant = hits.map((h) => h.memory).filter((m) => !criticalIds.has(m.id));
+        }
+        const merged = [...critical, ...relevant];
+        if (merged.length > 0) {
+            const formatted = formatMemoriesForPrompt(merged, 2000);
             if (formatted) {
                 memoryBlock = `\n\n${formatted}`;
             }