@opengsd/gsd-pi 1.3.0 → 1.4.0

package/dist/resources/extensions/gsd/unit-registry.js

@@ -51,7 +51,13 @@ export const UNIT_REGISTRY = {
         scopeClass: "standard",
         phaseChain: ["research"],
         toolContract: {
-            allowedGsdTools: ["gsd_summary_save", "gsd_decision_save"],
+            allowedGsdTools: [
+                "gsd_summary_save",
+                "gsd_decision_save",
+                "gsd_exec",
+                "gsd_exec_search",
+                "gsd_resume",
+            ],
             requiredWorkflowTools: ["gsd_summary_save"],
         },
     },
@@ -64,10 +70,11 @@ export const UNIT_REGISTRY = {
                 "gsd_milestone_status",
                 "gsd_plan_milestone",
                 "gsd_plan_slice",
+                "gsd_plan_task",
                 "gsd_decision_save",
                 "gsd_requirement_update",
             ],
-            requiredWorkflowTools: ["gsd_milestone_status", "gsd_plan_milestone", "gsd_plan_slice"],
+            requiredWorkflowTools: ["gsd_milestone_status", "gsd_plan_milestone", "gsd_plan_slice", "gsd_plan_task"],
         },
     },
     "discuss-milestone": {
@@ -107,7 +114,15 @@ export const UNIT_REGISTRY = {
         scopeClass: "section-close",
         phaseChain: ["validation", "planning"],
         toolContract: {
-            allowedGsdTools: ["gsd_milestone_status", "gsd_validate_milestone", "gsd_reassess_roadmap", "subagent"],
+            allowedGsdTools: [
+                "gsd_milestone_status",
+                "gsd_exec",
+                "gsd_exec_search",
+                "gsd_resume",
+                "gsd_validate_milestone",
+                "gsd_reassess_roadmap",
+                "subagent",
+            ],
             requiredWorkflowTools: ["gsd_milestone_status", "gsd_validate_milestone", "gsd_reassess_roadmap"],
         },
     },
@@ -118,6 +133,9 @@ export const UNIT_REGISTRY = {
         toolContract: {
             allowedGsdTools: [
                 "gsd_milestone_status",
+                "gsd_exec",
+                "gsd_exec_search",
+                "gsd_resume",
                 "gsd_requirement_update",
                 "gsd_summary_save",
                 "gsd_complete_milestone",
@@ -136,7 +154,14 @@ export const UNIT_REGISTRY = {
         scopeClass: "standard",
         phaseChain: ["research"],
         toolContract: {
-            allowedGsdTools: ["gsd_summary_save", "gsd_decision_save"],
+            allowedGsdTools: [
+                "gsd_milestone_status",
+                "gsd_summary_save",
+                "gsd_decision_save",
+                "gsd_exec",
+                "gsd_exec_search",
+                "gsd_resume",
+            ],
             requiredWorkflowTools: ["gsd_summary_save"],
         },
     },
@@ -145,8 +170,17 @@ export const UNIT_REGISTRY = {
         scopeClass: "standard",
         phaseChain: ["planning"],
         toolContract: {
-            allowedGsdTools: ["gsd_plan_slice", "gsd_reassess_roadmap", "gsd_decision_save"],
-            requiredWorkflowTools: ["gsd_plan_slice", "gsd_reassess_roadmap"],
+            allowedGsdTools: [
+                "gsd_milestone_status",
+                "gsd_plan_slice",
+                "gsd_plan_task",
+                "gsd_reassess_roadmap",
+                "gsd_decision_save",
+                "gsd_exec",
+                "gsd_exec_search",
+                "gsd_resume",
+            ],
+            requiredWorkflowTools: ["gsd_plan_slice", "gsd_plan_task", "gsd_reassess_roadmap"],
         },
     },
     "refine-slice": {
@@ -154,7 +188,14 @@ export const UNIT_REGISTRY = {
         scopeClass: "standard",
         phaseChain: ["planning"],
         toolContract: {
-            allowedGsdTools: ["gsd_plan_slice", "gsd_decision_save"],
+            allowedGsdTools: [
+                "gsd_milestone_status",
+                "gsd_plan_slice",
+                "gsd_decision_save",
+                "gsd_exec",
+                "gsd_exec_search",
+                "gsd_resume",
+            ],
             requiredWorkflowTools: ["gsd_plan_slice"],
         },
     },
@@ -173,7 +214,10 @@ export const UNIT_REGISTRY = {
         phaseChain: ["completion"],
         toolContract: {
             allowedGsdTools: [
+                "gsd_milestone_status",
                 "gsd_exec",
+                "gsd_exec_search",
+                "gsd_resume",
                 "gsd_slice_complete",
                 "gsd_task_reopen",
                 "gsd_replan_slice",
@@ -184,6 +228,7 @@ export const UNIT_REGISTRY = {
                 "subagent",
             ],
             requiredWorkflowTools: [
+                "gsd_milestone_status",
                 "gsd_exec",
                 "gsd_capture_thought",
                 "gsd_slice_complete",
@@ -255,7 +300,13 @@ export const UNIT_REGISTRY = {
         scopeClass: "execute-task",
         phaseChain: ["execution"],
         toolContract: {
-            allowedGsdTools: ["gsd_task_complete", "gsd_summary_save", "gsd_decision_save"],
+            allowedGsdTools: [
+                "gsd_milestone_status",
+                "gsd_task_complete",
+                "gsd_exec",
+                "gsd_summary_save",
+                "gsd_decision_save",
+            ],
             requiredWorkflowTools: ["gsd_task_complete", "gsd_summary_save"],
         },
     },
@@ -342,12 +393,15 @@ export const UNIT_REGISTRY = {
             requiredWorkflowTools: ["ask_user_questions"],
         },
     },
+    // research-project dispatches 4 parallel scout subagents (Task calls); each scout
+    // writes one file under .gsd/research/ directly. The parent coordinator does not
+    // call gsd_summary_save or gsd_decision_save — the scouts own their own output.
     "research-project": {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["research"],
         toolContract: {
-            allowedGsdTools: ["gsd_summary_save", "gsd_decision_save"],
+            allowedGsdTools: [],
             requiredWorkflowTools: [],
         },
     },

package/dist/resources/extensions/gsd/unmerged-milestone-guard.js

@@ -1,22 +1,38 @@
 // Project/App: gsd-pi
 // File Purpose: Block new workflow entry when completed milestone branches are still unmerged.
-import { nativeBranchExists, nativeDetectMainBranch, nativeDiffNumstat, } from "./native-git-bridge.js";
+import { execFileSync } from "node:child_process";
+import { nativeBranchExists, nativeDetectMainBranch, nativeDiffNumstat, nativeIsAncestor, } from "./native-git-bridge.js";
 import { autoWorktreeBranch } from "./auto-worktree.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import { getAllMilestones } from "./gsd-db.js";
 import { resolveMilestoneIntegrationBranch } from "./git-service.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { captureRootDirtySnapshot } from "./root-write-leak-guard.js";
 import { isClosedStatus } from "./status-guards.js";
 const BLOCKED_COMMANDS = new Set([
     "auto",
     "next",
-    "parallel",
     "start",
     "workflow",
     "new-milestone",
     "new-project",
     "do",
+    "discuss-phase",
+    "plan-phase",
+    "execute-phase",
+    "spec-phase",
+    "mvp-phase",
+    "ui-phase",
+    "ai-integration-phase",
+    "ultraplan-phase",
+    "validate-phase",
+    "docs-update",
+    "review-backlog",
+    "import",
+    "ingest-docs",
+    "secure-phase",
+    "plan-review-convergence",
+    "autonomous",
+    "resume-work",
     "execute-task",
     "research-milestone",
     "plan-slice",
@@ -26,13 +42,53 @@ const BLOCKED_COMMANDS = new Set([
     "validate-milestone",
     "complete-milestone",
 ]);
+const UNMERGED_SAFE_PARALLEL_SUBCOMMANDS = new Set([
+    "status",
+    "watch",
+]);
 function isRuntimePath(path) {
     return path === ".gsd" || path.startsWith(".gsd/");
 }
+function captureDirtyPathStatusSnapshot(rootPath) {
+    const snapshot = new Map();
+    let status = "";
+    try {
+        status = execFileSync("git", ["status", "--porcelain", "--untracked-files=all"], {
+            cwd: rootPath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+    }
+    catch {
+        return snapshot;
+    }
+    for (const line of status.split("\n")) {
+        if (!line.trim())
+            continue;
+        const code = line.slice(0, 2);
+        const path = line.slice(3).replace(/^"|"$/g, "");
+        if (!path || isRuntimePath(path))
+            continue;
+        snapshot.set(path, {
+            path,
+            status: code.trim() || code,
+        });
+    }
+    return snapshot;
+}
 function formatCommandLabel(attemptedCommand) {
     const trimmed = attemptedCommand.trim();
     return trimmed ? `/gsd ${trimmed}` : "/gsd";
 }
+function hasFlag(command, flag) {
+    const escaped = flag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(?:^|\\s)${escaped}(?=\\s|$)`).test(command);
+}
+function isMutatingPhaseCommand(subcommand) {
+    if (!subcommand)
+        return false;
+    return ["add", "create", "new", "insert", "remove", "edit"].includes(subcommand);
+}
 function resolveIntegrationBranch(base, milestoneId) {
     const prefs = loadEffectiveGSDPreferences(base)?.preferences?.git ?? {};
     const resolution = resolveMilestoneIntegrationBranch(base, milestoneId, prefs);
@@ -57,12 +113,30 @@ export function isUnmergedMilestoneAllowedCommand(trimmed) {
     if (name === "dispatch") {
         return subcommand === "complete" || subcommand === "complete-milestone";
     }
+    if (name === "audit-fix") {
+        return hasFlag(command, "--dry-run");
+    }
+    if (name === "code-review") {
+        return !hasFlag(command, "--fix");
+    }
+    if (name === "docs-update") {
+        return hasFlag(command, "--verify-only");
+    }
+    if (name === "parallel") {
+        return UNMERGED_SAFE_PARALLEL_SUBCOMMANDS.has(subcommand ?? "");
+    }
+    if (name === "phase") {
+        return !isMutatingPhaseCommand(subcommand);
+    }
+    if (name === "progress") {
+        return !hasFlag(command, "--next") && !hasFlag(command, "--do");
+    }
     return !BLOCKED_COMMANDS.has(name);
 }
 export async function findUnmergedCompletedMilestones(base) {
     await ensureDbOpen(base);
     const blockers = [];
-    const dirtyByPath = captureRootDirtySnapshot(base);
+    let dirtyByPath = null;
     for (const milestone of getAllMilestones()) {
         if (!isClosedStatus(milestone.status))
             continue;
@@ -72,19 +146,31 @@ export async function findUnmergedCompletedMilestones(base) {
         const integrationBranch = resolveIntegrationBranch(base, milestone.id);
         if (!integrationBranch || integrationBranch === branch)
             continue;
+        // The milestone is merged when its branch tip is reachable from the
+        // integration branch tip — true for fast-forward, --no-ff, and squash
+        // merges alike. A raw diff is the wrong predicate: a --no-ff merge that
+        // took main's side for some conflicts leaves the branch tip differing from
+        // main, which the diff check would misread as "unmerged" (#825). The diff
+        // below remains the correct fallback only when the branch is NOT yet an
+        // ancestor — i.e. the merge is genuinely still pending.
+        if (nativeIsAncestor(base, branch, integrationBranch))
+            continue;
         const files = nativeDiffNumstat(base, integrationBranch, branch)
             .map((entry) => entry.path)
             .filter((path) => path && !isRuntimePath(path));
         const uniqueFiles = [...new Set(files)].sort();
         if (uniqueFiles.length === 0)
             continue;
+        if (!dirtyByPath)
+            dirtyByPath = captureDirtyPathStatusSnapshot(base);
+        const dirtySnapshot = dirtyByPath;
         blockers.push({
             milestoneId: milestone.id,
             branch,
             integrationBranch,
             files: uniqueFiles,
             dirtyOverlap: uniqueFiles
-                .map((path) => dirtyByPath.get(path))
+                .map((path) => dirtySnapshot.get(path))
                 .filter((entry) => Boolean(entry)),
         });
     }

package/dist/resources/extensions/gsd/validation-block-guard.js

@@ -5,7 +5,7 @@ import { getAutoWorktreePath, isInAutoWorktree } from "./auto-worktree.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import { refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 import { getIsolationMode } from "./preferences.js";
-import { deriveState } from "./state.js";
+import { deriveState, invalidateStateCache } from "./state.js";
 import { detectWorktreeName } from "./worktree.js";
 const VALIDATION_BLOCK_RE = /milestone validation returned needs-(?:attention|remediation)|validation verdict is needs-(?:attention|remediation)/i;
 const VALIDATION_SAFE_DISPATCH_COMMANDS = new Set([
@@ -21,6 +21,27 @@ const VALIDATION_BLOCKED_COMMANDS = new Set([
     "ship",
     "complete-milestone",
     "do",
+    "discuss-phase",
+    "import",
+    "ingest-docs",
+    "review-backlog",
+    "docs-update",
+    "secure-phase",
+    "plan-phase",
+    "execute-phase",
+    "spec-phase",
+    "mvp-phase",
+    "ui-phase",
+    "ai-integration-phase",
+    "ultraplan-phase",
+    "plan-review-convergence",
+    "autonomous",
+    "resume-work",
+    "discuss-phase",
+    "import",
+    "ingest-docs",
+    "review-backlog",
+    "secure-phase",
 ]);
 const VALIDATION_BLOCKED_PARALLEL_SUBCOMMANDS = new Set([
     "",
@@ -38,6 +59,15 @@ const VALIDATION_SAFE_WORKFLOW_SUBCOMMANDS = new Set([
     "install",
     "uninstall",
 ]);
+function hasFlag(command, flag) {
+    const escaped = flag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(?:^|\\s)${escaped}(?=\\s|$)`).test(command);
+}
+function isMutatingPhaseCommand(subcommand) {
+    if (!subcommand)
+        return false;
+    return ["add", "create", "new", "insert", "remove", "edit"].includes(subcommand);
+}
 export function isValidationBlockedState(state) {
     if (state.phase !== "blocked")
         return false;
@@ -57,6 +87,21 @@ export function isValidationBlockAllowedCommand(trimmed) {
     if (name === "workflow") {
         return VALIDATION_SAFE_WORKFLOW_SUBCOMMANDS.has(subcommand ?? "");
     }
+    if (name === "audit-fix") {
+        return hasFlag(command, "--dry-run");
+    }
+    if (name === "code-review") {
+        return !hasFlag(command, "--fix");
+    }
+    if (name === "docs-update") {
+        return hasFlag(command, "--verify-only");
+    }
+    if (name === "phase") {
+        return !isMutatingPhaseCommand(subcommand);
+    }
+    if (name === "progress") {
+        return !hasFlag(command, "--next") && !hasFlag(command, "--do");
+    }
     return !VALIDATION_BLOCKED_COMMANDS.has(name);
 }
 export function formatValidationBlockedMessage(state, attemptedCommand = "") {
@@ -71,9 +116,7 @@ export function formatValidationBlockedMessage(state, attemptedCommand = "") {
         ...blockers,
     ].join("\n\n");
 }
-export async function getValidationBlockMessageForBase(base, attemptedCommand = "") {
-    await ensureDbOpen(base);
-    refreshWorkflowDatabaseFromDisk();
+async function deriveValidationBlockState(base) {
     let state = await deriveState(base);
     if (state.activeMilestone &&
         getIsolationMode(base) === "worktree" &&
@@ -84,5 +127,12 @@ export async function getValidationBlockMessageForBase(base, attemptedCommand =
             state = await deriveState(wtPath);
         }
     }
+    return state;
+}
+export async function getValidationBlockMessageForBase(base, attemptedCommand = "") {
+    await ensureDbOpen(base);
+    refreshWorkflowDatabaseFromDisk();
+    invalidateStateCache();
+    const state = await deriveValidationBlockState(base);
     return formatValidationBlockedMessage(state, attemptedCommand);
 }

package/dist/resources/extensions/gsd/verification-gate.js

@@ -201,6 +201,13 @@ export function formatFailureContext(result) {
     }
     return header + body;
 }
+export function formatFailureSignature(result) {
+    return result.checks
+        .filter((check) => check.exitCode !== 0)
+        .map((check) => `${check.command.trim()}#${check.exitCode}`)
+        .sort()
+        .join("\n");
+}
 // ─── Gate Execution ─────────────────────────────────────────────────────────
 /** Characters that indicate shell control syntax when unquoted in a command string. */
 const UNQUOTED_SHELL_CONTROL_CHARS = new Set([";", "<", ">"]);

package/dist/resources/extensions/gsd/visualizer-data.js

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { deriveState } from './state.js';
 import { parseSummary, loadFile } from './files.js';
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from './gsd-db.js';
+import { openExistingWorkflowDatabase } from './db-workspace.js';
 import { parseRoadmap, parsePlan } from './parsers-legacy.js';
 import { findMilestoneIds } from './milestone-ids.js';
 import { resolveMilestoneFile, resolveSliceFile, resolveGsdRootFile, gsdRoot } from './paths.js';
@@ -15,6 +16,7 @@ import { generateSkillHealthReport } from './skill-health.js';
 import { runEnvironmentChecks } from './doctor-environment.js';
 import { computeProgressScore } from './progress-score.js';
 import { getHealthHistory } from './doctor-proactive.js';
+import { getActiveMemories, getActiveMemoriesRanked } from './memory-store.js';
 // ─── Critical Path ────────────────────────────────────────────────────────────
 export function computeCriticalPath(milestones) {
     const empty = {
@@ -351,6 +353,36 @@ function loadKnowledge(basePath) {
     }
     return { rules, patterns, lessons, exists: true };
 }
+// ─── Memory Loader ────────────────────────────────────────────────────────────
+const VISUALIZER_MEMORY_LIMIT = 20;
+const VISUALIZER_MEMORY_CONTENT_LIMIT = 2000;
+function ensureVisualizerDb(basePath) {
+    if (isDbAvailable())
+        return;
+    openExistingWorkflowDatabase(basePath);
+}
+function loadMemories() {
+    const allActive = getActiveMemories();
+    const ranked = getActiveMemoriesRanked(VISUALIZER_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,
+        })),
+    };
+}
+function limitMemoryContent(content) {
+    if (content.length <= VISUALIZER_MEMORY_CONTENT_LIMIT)
+        return content;
+    return `${content.slice(0, VISUALIZER_MEMORY_CONTENT_LIMIT).trimEnd()}...`;
+}
 // ─── Health Loader ────────────────────────────────────────────────────────────
 function loadHealth(units, totals, basePath) {
     const prefs = loadEffectiveGSDPreferences();
@@ -524,6 +556,7 @@ function readFileCached(filePath) {
 }
 // ─── Loader ───────────────────────────────────────────────────────────────────
 export async function loadVisualizerData(basePath) {
+    ensureVisualizerDb(basePath);
     const state = await deriveState(basePath);
     const milestoneIds = findMilestoneIds(basePath);
     const milestones = [];
@@ -640,6 +673,7 @@ export async function loadVisualizerData(basePath) {
     const agentActivity = loadAgentActivity(units, milestones);
     const { changelog, verifications: sliceVerifications } = await loadChangelogAndVerifications(basePath, milestones);
     const knowledge = loadKnowledge(basePath);
+    const memories = loadMemories();
     const allCaptures = loadAllCaptures(basePath);
     const pendingCount = countPendingCaptures(basePath);
     const captures = {
@@ -666,6 +700,7 @@ export async function loadVisualizerData(basePath) {
         changelog,
         sliceVerifications,
         knowledge,
+        memories,
         captures,
         health,
         discussion,

package/dist/resources/extensions/gsd/visualizer-views.js

@@ -705,11 +705,16 @@ export function renderExportView(_data, th, _width, lastExportPath) {
 export function renderKnowledgeView(data, th, width) {
     const lines = [];
     const knowledge = data.knowledge;
-    if (!knowledge.exists) {
+    const memories = data.memories;
+    if (!knowledge.exists && memories.entries.length === 0) {
         lines.push(th.fg("dim", "No KNOWLEDGE.md found"));
         return lines;
     }
-    if (knowledge.rules.length === 0 && knowledge.patterns.length === 0 && knowledge.lessons.length === 0) {
+    if (knowledge.exists &&
+        knowledge.rules.length === 0 &&
+        knowledge.patterns.length === 0 &&
+        knowledge.lessons.length === 0 &&
+        memories.entries.length === 0) {
         lines.push(th.fg("dim", "KNOWLEDGE.md exists but is empty"));
         return lines;
     }
@@ -740,6 +745,20 @@ export function renderKnowledgeView(data, th, width) {
         }
         lines.push("");
     }
+    if (memories.entries.length > 0) {
+        const countLabel = memories.totalCount > memories.entries.length
+            ? `${memories.entries.length}/${memories.totalCount}`
+            : `${memories.totalCount}`;
+        lines.push(th.fg("accent", th.bold(`Memories (${countLabel})`)));
+        lines.push("");
+        for (const memory of memories.entries) {
+            const scope = memory.scope && memory.scope !== "project" ? ` ${th.fg("dim", `[${memory.scope}]`)}` : "";
+            const tags = memory.tags.length > 0 ? ` ${th.fg("dim", `#${memory.tags.join(" #")}`)}` : "";
+            lines.push(truncateToWidth(`  ${th.fg("accent", memory.id)}  (${memory.category}, ${memory.confidence.toFixed(2)}, hits ${memory.hitCount})${scope}${tags}`, width));
+            lines.push(truncateToWidth(`    ${memory.content}`, width));
+        }
+        lines.push("");
+    }
     return lines;
 }
 // ─── Captures View ───────────────────────────────────────────────────────────