gsd-pi 2.41.0 → 2.42.0-dev.1df898f

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

@@ -0,0 +1,225 @@
+/**
+ * graph.ts — Pure data module for GRAPH.yaml workflow step tracking.
+ *
+ * Provides types and functions for reading, writing, and querying the
+ * step graph that drives CustomWorkflowEngine. Zero engine dependencies.
+ *
+ * GRAPH.yaml lives in a run directory and tracks step statuses
+ * (pending → active → complete) with optional dependency edges.
+ *
+ * Observability:
+ * - readGraph/writeGraph use YAML on disk — human-readable, diffable,
+ *   inspectable with `cat` or any YAML viewer.
+ * - Each GraphStep has status, startedAt, finishedAt fields visible in GRAPH.yaml.
+ * - writeGraph uses atomic write (tmp + rename) for crash safety.
+ * - All operations are immutable — callers always get a new graph object.
+ */
+import { parse, stringify } from "yaml";
+import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+// ─── YAML schema mapping ─────────────────────────────────────────────────
+const GRAPH_FILENAME = "GRAPH.yaml";
+// ─── Functions ───────────────────────────────────────────────────────────
+/**
+ * Read and parse GRAPH.yaml from a run directory.
+ *
+ * @param runDir — directory containing GRAPH.yaml
+ * @returns Parsed workflow graph
+ * @throws Error if file doesn't exist or YAML is malformed
+ */
+export function readGraph(runDir) {
+    const filePath = join(runDir, GRAPH_FILENAME);
+    if (!existsSync(filePath)) {
+        throw new Error(`GRAPH.yaml not found: ${filePath}`);
+    }
+    const raw = readFileSync(filePath, "utf-8");
+    const yaml = parse(raw);
+    if (!yaml?.steps || !Array.isArray(yaml.steps)) {
+        throw new Error(`Invalid GRAPH.yaml: missing or invalid 'steps' array in ${filePath}`);
+    }
+    return {
+        steps: yaml.steps.map((s) => ({
+            id: s.id,
+            title: s.title,
+            status: s.status,
+            prompt: s.prompt,
+            dependsOn: s.depends_on ?? [],
+            ...(s.parent_step_id != null ? { parentStepId: s.parent_step_id } : {}),
+            ...(s.started_at != null ? { startedAt: s.started_at } : {}),
+            ...(s.finished_at != null ? { finishedAt: s.finished_at } : {}),
+        })),
+        metadata: {
+            name: yaml.metadata?.name ?? "unnamed",
+            createdAt: yaml.metadata?.created_at ?? new Date().toISOString(),
+        },
+    };
+}
+/**
+ * Write a workflow graph to GRAPH.yaml in a run directory.
+ * Creates the directory if it doesn't exist. Write is atomic (write + rename).
+ *
+ * @param runDir — directory to write GRAPH.yaml into
+ * @param graph — the workflow graph to serialize
+ */
+export function writeGraph(runDir, graph) {
+    if (!existsSync(runDir)) {
+        mkdirSync(runDir, { recursive: true });
+    }
+    const yamlData = {
+        steps: graph.steps.map((s) => ({
+            id: s.id,
+            title: s.title,
+            status: s.status,
+            prompt: s.prompt,
+            depends_on: s.dependsOn.length > 0 ? s.dependsOn : undefined,
+            parent_step_id: s.parentStepId ?? undefined,
+            started_at: s.startedAt ?? undefined,
+            finished_at: s.finishedAt ?? undefined,
+        })),
+        metadata: {
+            name: graph.metadata.name,
+            created_at: graph.metadata.createdAt,
+        },
+    };
+    const filePath = join(runDir, GRAPH_FILENAME);
+    const tmpPath = filePath + ".tmp";
+    const content = stringify(yamlData);
+    writeFileSync(tmpPath, content, "utf-8");
+    // Atomic rename for crash safety
+    renameSync(tmpPath, filePath);
+}
+/**
+ * Get the next pending step whose dependencies are all complete.
+ *
+ * Returns the first step (in array order) with status "pending" where
+ * every step in its `dependsOn` list has status "complete".
+ *
+ * @param graph — the workflow graph to query
+ * @returns The next dispatchable step, or null if none available
+ */
+export function getNextPendingStep(graph) {
+    const statusMap = new Map(graph.steps.map((s) => [s.id, s.status]));
+    for (const step of graph.steps) {
+        if (step.status !== "pending")
+            continue;
+        const depsComplete = step.dependsOn.every((depId) => statusMap.get(depId) === "complete");
+        if (depsComplete)
+            return step;
+    }
+    return null;
+}
+/**
+ * Return a new graph with the specified step marked as "complete".
+ * Immutable — does not mutate the input graph.
+ *
+ * @param graph — the current workflow graph
+ * @param stepId — ID of the step to mark complete
+ * @returns New graph with the step's status set to "complete"
+ * @throws Error if stepId is not found in the graph
+ */
+export function markStepComplete(graph, stepId) {
+    const found = graph.steps.some((s) => s.id === stepId);
+    if (!found) {
+        throw new Error(`Step not found: ${stepId}`);
+    }
+    return {
+        ...graph,
+        steps: graph.steps.map((s) => s.id === stepId
+            ? { ...s, status: "complete", finishedAt: new Date().toISOString() }
+            : s),
+    };
+}
+// ─── Iteration expansion ─────────────────────────────────────────────────
+/**
+ * Expand an iterate step into concrete instances. Pure and deterministic —
+ * identical inputs always produce identical output.
+ *
+ * Given a parent step with status "pending" and an array of matched items,
+ * creates one instance step per item, marks the parent as "expanded", and
+ * rewrites any downstream dependsOn references from the parent ID to the
+ * full set of instance IDs.
+ *
+ * @param graph — the current workflow graph (not mutated)
+ * @param stepId — ID of the iterate step to expand
+ * @param items — matched items from the source artifact
+ * @param promptTemplate — template with {{item}} placeholders
+ * @returns New WorkflowGraph with instances inserted and deps rewritten
+ * @throws Error if stepId not found or step is not pending
+ */
+export function expandIteration(graph, stepId, items, promptTemplate) {
+    const parentIndex = graph.steps.findIndex((s) => s.id === stepId);
+    if (parentIndex === -1) {
+        throw new Error(`expandIteration: step not found: ${stepId}`);
+    }
+    const parentStep = graph.steps[parentIndex];
+    if (parentStep.status !== "pending") {
+        throw new Error(`expandIteration: step "${stepId}" has status "${parentStep.status}", expected "pending"`);
+    }
+    // Create instance steps
+    const instanceIds = [];
+    const instances = items.map((item, i) => {
+        const instanceId = `${stepId}--${String(i + 1).padStart(3, "0")}`;
+        instanceIds.push(instanceId);
+        return {
+            id: instanceId,
+            title: `${parentStep.title}: ${item}`,
+            status: "pending",
+            prompt: promptTemplate.replace(/\{\{item\}\}/g, () => item),
+            dependsOn: [...parentStep.dependsOn],
+            parentStepId: stepId,
+        };
+    });
+    // Build new steps array: copy everything, mark parent as expanded,
+    // insert instances right after the parent, rewrite downstream deps.
+    const newSteps = [];
+    for (let i = 0; i < graph.steps.length; i++) {
+        if (i === parentIndex) {
+            // Mark parent as expanded
+            newSteps.push({ ...parentStep, status: "expanded" });
+            // Insert instances immediately after parent
+            newSteps.push(...instances);
+        }
+        else {
+            const step = graph.steps[i];
+            // Rewrite dependsOn: replace parent ID with all instance IDs
+            const hasDep = step.dependsOn.includes(stepId);
+            if (hasDep) {
+                const rewritten = step.dependsOn.flatMap((dep) => dep === stepId ? instanceIds : [dep]);
+                newSteps.push({ ...step, dependsOn: rewritten });
+            }
+            else {
+                newSteps.push(step);
+            }
+        }
+    }
+    return {
+        ...graph,
+        steps: newSteps,
+    };
+}
+// ─── Definition → Graph conversion ──────────────────────────────────────
+/**
+ * Convert a parsed WorkflowDefinition into a WorkflowGraph with all
+ * steps in "pending" status. Used by run-manager to generate the initial
+ * GRAPH.yaml for a new run.
+ *
+ * @param def — a validated WorkflowDefinition from definition-loader
+ * @returns WorkflowGraph with pending steps and metadata from the definition
+ */
+export function initializeGraph(def) {
+    return {
+        steps: def.steps.map((s) => ({
+            id: s.id,
+            title: s.name,
+            status: "pending",
+            prompt: s.prompt,
+            dependsOn: s.requires ?? [],
+        })),
+        metadata: {
+            name: def.name,
+            createdAt: new Date().toISOString(),
+        },
+    };
+}
+/** @deprecated Use initializeGraph instead. Kept for backward compatibility. */
+export { initializeGraph as graphFromDefinition };

package/dist/resources/extensions/gsd/gsd-db.js

@@ -118,7 +118,7 @@ function openRawDb(path) {
     return new Database(path);
 }
 // ─── Schema ────────────────────────────────────────────────────────────────
-const SCHEMA_VERSION = 3;
+const SCHEMA_VERSION = 4;
 function initSchema(db, fileBacked) {
     // WAL mode for file-backed databases (must be outside transaction)
     if (fileBacked) {
@@ -142,6 +142,7 @@ function initSchema(db, fileBacked) {
         choice TEXT NOT NULL DEFAULT '',
         rationale TEXT NOT NULL DEFAULT '',
         revisable TEXT NOT NULL DEFAULT '',
+        made_by TEXT NOT NULL DEFAULT 'agent',
         superseded_by TEXT DEFAULT NULL
       )
     `);
@@ -273,6 +274,15 @@ function migrateSchema(db) {
             db.exec("CREATE VIEW active_memories AS SELECT * FROM memories WHERE superseded_by IS NULL");
             db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({ ":version": 3, ":applied_at": new Date().toISOString() });
         }
+        // v3 → v4: add made_by column to decisions table
+        if (currentVersion < 4) {
+            // Add made_by column — default 'agent' for existing rows (pre-attribution decisions)
+            db.exec(`ALTER TABLE decisions ADD COLUMN made_by TEXT NOT NULL DEFAULT 'agent'`);
+            // Recreate views to pick up new columns (SQLite expands SELECT * at view creation time)
+            db.exec("DROP VIEW IF EXISTS active_decisions");
+            db.exec("CREATE VIEW active_decisions AS SELECT * FROM decisions WHERE superseded_by IS NULL");
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({ ":version": 4, ":applied_at": new Date().toISOString() });
+        }
         db.exec("COMMIT");
     }
     catch (err) {
@@ -375,8 +385,8 @@ export function insertDecision(d) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
     currentDb
-        .prepare(`INSERT INTO decisions (id, when_context, scope, decision, choice, rationale, revisable, superseded_by)
-     VALUES (:id, :when_context, :scope, :decision, :choice, :rationale, :revisable, :superseded_by)`)
+        .prepare(`INSERT INTO decisions (id, when_context, scope, decision, choice, rationale, revisable, made_by, superseded_by)
+     VALUES (:id, :when_context, :scope, :decision, :choice, :rationale, :revisable, :made_by, :superseded_by)`)
         .run({
         ":id": d.id,
         ":when_context": d.when_context,
@@ -385,6 +395,7 @@ export function insertDecision(d) {
         ":choice": d.choice,
         ":rationale": d.rationale,
         ":revisable": d.revisable,
+        ":made_by": d.made_by ?? "agent",
         ":superseded_by": d.superseded_by,
     });
 }
@@ -406,6 +417,7 @@ export function getDecisionById(id) {
         choice: row["choice"],
         rationale: row["rationale"],
         revisable: row["revisable"],
+        made_by: row["made_by"] ?? "agent",
         superseded_by: row["superseded_by"] ?? null,
     };
 }
@@ -425,6 +437,7 @@ export function getActiveDecisions() {
         choice: row["choice"],
         rationale: row["rationale"],
         revisable: row["revisable"],
+        made_by: row["made_by"] ?? "agent",
         superseded_by: null,
     }));
 }
@@ -537,8 +550,8 @@ export function upsertDecision(d) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
     currentDb
-        .prepare(`INSERT OR REPLACE INTO decisions (id, when_context, scope, decision, choice, rationale, revisable, superseded_by)
-     VALUES (:id, :when_context, :scope, :decision, :choice, :rationale, :revisable, :superseded_by)`)
+        .prepare(`INSERT OR REPLACE INTO decisions (id, when_context, scope, decision, choice, rationale, revisable, made_by, superseded_by)
+     VALUES (:id, :when_context, :scope, :decision, :choice, :rationale, :revisable, :made_by, :superseded_by)`)
         .run({
         ":id": d.id,
         ":when_context": d.when_context,
@@ -547,6 +560,7 @@ export function upsertDecision(d) {
         ":choice": d.choice,
         ":rationale": d.rationale,
         ":revisable": d.revisable,
+        ":made_by": d.made_by ?? "agent",
         ":superseded_by": d.superseded_by ?? null,
     });
 }
@@ -649,8 +663,11 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
     try {
         adapter.exec(`ATTACH DATABASE '${worktreeDbPath}' AS wt`);
         try {
+            // Check if attached wt database has the made_by column (legacy v3 worktrees won't)
+            const wtInfo = adapter.prepare("PRAGMA wt.table_info('decisions')").all();
+            const hasMadeBy = wtInfo.some((col) => col["name"] === "made_by");
             const decConf = adapter
-                .prepare(`SELECT m.id FROM decisions m INNER JOIN wt.decisions w ON m.id = w.id WHERE m.decision != w.decision OR m.choice != w.choice OR m.rationale != w.rationale OR m.superseded_by IS NOT w.superseded_by`)
+                .prepare(`SELECT m.id FROM decisions m INNER JOIN wt.decisions w ON m.id = w.id WHERE m.decision != w.decision OR m.choice != w.choice OR m.rationale != w.rationale OR ${hasMadeBy ? "m.made_by != w.made_by" : "'agent' != 'agent'"} OR m.superseded_by IS NOT w.superseded_by`)
                 .all();
             for (const row of decConf)
                 conflicts.push(`decision ${row["id"]}: modified in both`);
@@ -665,10 +682,10 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
                 const dR = adapter
                     .prepare(`
           INSERT OR REPLACE INTO decisions (
-            id, when_context, scope, decision, choice, rationale, revisable, superseded_by
+            id, when_context, scope, decision, choice, rationale, revisable, made_by, superseded_by
           )
           SELECT
-            id, when_context, scope, decision, choice, rationale, revisable, superseded_by
+            id, when_context, scope, decision, choice, rationale, revisable, ${hasMadeBy ? "made_by" : "'agent'"}, superseded_by
           FROM wt.decisions
         `)
                     .run();

package/dist/resources/extensions/gsd/guided-flow-queue.js

@@ -130,7 +130,7 @@ export async function showQueueAdd(ctx, pi, basePath, state) {
     // ── Build existing milestones context for the prompt ────────────────
     const existingContext = await buildExistingMilestonesContext(basePath, milestoneIds, state);
     // ── Determine next milestone ID ─────────────────────────────────────
-    // Note: the LLM will use the gsd_generate_milestone_id tool to get IDs
+    // Note: the LLM will use the gsd_milestone_generate_id tool to get IDs
     // at creation time, but we still mention the next ID in the preamble
     // for context about where the sequence is.
     const uniqueEnabled = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;

package/dist/resources/extensions/gsd/guided-flow.js

@@ -20,6 +20,7 @@ import { join } from "node:path";
 import { readFileSync, existsSync, mkdirSync, readdirSync, unlinkSync } from "node:fs";
 import { readSessionLockData, isSessionLockProcessAlive } from "./session-lock.js";
 import { nativeIsRepo, nativeInit } from "./native-git-bridge.js";
+import { isInheritedRepo } from "./repo-identity.js";
 import { ensureGitignore, ensurePreferences, untrackRuntimeFiles } from "./gitignore.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { detectProjectState } from "./detection.js";
@@ -37,7 +38,7 @@ import { getErrorMessage } from "./error-utils.js";
 // ─── ID Generation with Reservation ─────────────────────────────────────────
 /**
  * Generate the next milestone ID, accounting for reserved IDs, and reserve it.
- * Ensures any preview ID shown in the UI matches what `gsd_generate_milestone_id`
+ * Ensures any preview ID shown in the UI matches what `gsd_milestone_generate_id`
  * will later return.
  */
 function nextMilestoneIdReserved(existingIds, uniqueEnabled) {
@@ -277,7 +278,7 @@ function buildHeadlessDiscussPrompt(nextId, seedContext, _basePath) {
  * Ensures git repo, .gsd/ structure, gitignore, and preferences all exist.
  */
 function bootstrapGsdProject(basePath) {
-    if (!nativeIsRepo(basePath)) {
+    if (!nativeIsRepo(basePath) || isInheritedRepo(basePath)) {
         const mainBranch = loadEffectiveGSDPreferences()?.preferences?.git?.main_branch || "main";
         nativeInit(basePath, mainBranch);
     }
@@ -721,7 +722,10 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         // which will detect "no milestones" and start the discuss prompt
     }
     // ── Ensure git repo exists — GSD needs it for worktree isolation ──────
-    if (!nativeIsRepo(basePath)) {
+    // Also handle inherited repos: if basePath is a subdirectory of another
+    // git repo that has no .gsd, create a fresh repo to prevent cross-project
+    // state leaks (#1639).
+    if (!nativeIsRepo(basePath) || isInheritedRepo(basePath)) {
         const mainBranch = loadEffectiveGSDPreferences()?.preferences?.git?.main_branch || "main";
         nativeInit(basePath, mainBranch);
     }

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

@@ -0,0 +1,85 @@
+/**
+ * GSD Event Journal — structured JSONL event log for auto-mode iterations.
+ *
+ * Writes daily-rotated JSONL files to `.gsd/journal/YYYY-MM-DD.jsonl`.
+ * Zero imports from `auto/` — depends only on node:fs, node:path, and paths.ts.
+ *
+ * Observability:
+ * - Each line in the JSONL file is a self-contained JournalEntry
+ * - Events are grouped by flowId (one per iteration) with monotonic seq numbers
+ * - causedBy references enable causal chain reconstruction
+ * - queryJournal() enables programmatic filtering by flowId, eventType, unitId, time range
+ * - Silent failure: journal writes never throw — absence of events is the failure signal
+ */
+import { appendFileSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { gsdRoot } from "./paths.js";
+// ─── Emit ─────────────────────────────────────────────────────────────────────
+/**
+ * Append a journal event to the daily JSONL file.
+ *
+ * File path: `<gsdRoot>/journal/<YYYY-MM-DD>.jsonl`
+ * where the date is extracted from `entry.ts.slice(0, 10)`.
+ *
+ * Never throws — all errors are silently caught.
+ */
+export function emitJournalEvent(basePath, entry) {
+    try {
+        const journalDir = join(gsdRoot(basePath), "journal");
+        mkdirSync(journalDir, { recursive: true });
+        const dateStr = entry.ts.slice(0, 10);
+        const filePath = join(journalDir, `${dateStr}.jsonl`);
+        appendFileSync(filePath, JSON.stringify(entry) + "\n");
+    }
+    catch {
+        // Silent failure — journal must never break auto-mode
+    }
+}
+// ─── Query ────────────────────────────────────────────────────────────────────
+/**
+ * Read and filter journal entries from all daily JSONL files.
+ *
+ * Returns an empty array on any error (missing directory, corrupt files, etc.).
+ */
+export function queryJournal(basePath, filters) {
+    try {
+        const journalDir = join(gsdRoot(basePath), "journal");
+        const files = readdirSync(journalDir).filter(f => f.endsWith(".jsonl")).sort();
+        const entries = [];
+        for (const file of files) {
+            const raw = readFileSync(join(journalDir, file), "utf-8");
+            for (const line of raw.split("\n")) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const entry = JSON.parse(line);
+                    entries.push(entry);
+                }
+                catch {
+                    // Skip malformed lines
+                }
+            }
+        }
+        if (!filters)
+            return entries;
+        return entries.filter(e => {
+            if (filters.flowId && e.flowId !== filters.flowId)
+                return false;
+            if (filters.eventType && e.eventType !== filters.eventType)
+                return false;
+            if (filters.rule && e.rule !== filters.rule)
+                return false;
+            if (filters.unitId && e.data?.unitId !== filters.unitId)
+                return false;
+            if (filters.after && e.ts < filters.after)
+                return false;
+            if (filters.before && e.ts > filters.before)
+                return false;
+            return true;
+        });
+    }
+    catch {
+        // Missing directory, permission errors, etc. — return empty
+        return [];
+    }
+}

package/dist/resources/extensions/gsd/md-importer.js

@@ -9,6 +9,7 @@ import { upsertDecision, upsertRequirement, insertArtifact, openDatabase, transa
 import { resolveGsdRootFile, milestonesDir, gsdRoot, resolveTaskFiles, } from './paths.js';
 import { findMilestoneIds } from './guided-flow.js';
 // ─── DECISIONS.md Parser ───────────────────────────────────────────────────
+const VALID_MADE_BY = new Set(['human', 'agent', 'collaborative']);
 /**
  * Parse a DECISIONS.md markdown table into Decision objects (without seq).
  * Detects `(amends DXXX)` in the Decision column to build supersession info.
@@ -49,6 +50,9 @@ export function parseDecisionsTable(content) {
         const choice = cells[4].trim();
         const rationale = cells[5].trim();
         const revisable = cells[6].trim();
+        // Made By column is optional for backward compatibility — defaults to 'agent'
+        const rawMadeBy = cells.length >= 8 ? cells[7].trim().toLowerCase() : 'agent';
+        const made_by = (VALID_MADE_BY.has(rawMadeBy) ? rawMadeBy : 'agent');
         // Detect (amends DXXX) in the Decision column
         const amendsMatch = decisionText.match(/\(amends\s+(D\d+)\)/i);
         if (amendsMatch) {
@@ -62,6 +66,7 @@ export function parseDecisionsTable(content) {
             choice,
             rationale,
             revisable,
+            made_by,
             superseded_by: null,
         });
     }

package/dist/resources/extensions/gsd/milestone-ids.js

@@ -62,7 +62,7 @@ export function nextMilestoneId(milestoneIds, uniqueEnabled) {
 /**
  * Module-level set of milestone IDs that have been previewed/promised to the
  * user but not yet materialised on disk. Both guided-flow (preview) and
- * gsd_generate_milestone_id (tool) share this set so the ID shown in the UI
+ * gsd_milestone_generate_id (tool) share this set so the ID shown in the UI
  * matches the one the tool returns.
  */
 const reservedMilestoneIds = new Set();

package/dist/resources/extensions/gsd/native-git-bridge.js

@@ -647,7 +647,7 @@ export function nativeCheckoutBranch(basePath, branch) {
         native.gitCheckoutBranch(basePath, branch);
         return;
     }
-    execSync(`git checkout ${branch}`, {
+    execFileSync("git", ["checkout", branch], {
         cwd: basePath,
         stdio: ["ignore", "pipe", "pipe"],
         encoding: "utf-8",
@@ -679,10 +679,11 @@ export function nativeMergeSquash(basePath, branch) {
         return native.gitMergeSquash(basePath, branch);
     }
     try {
-        execSync(`git merge --squash ${branch}`, {
+        execFileSync("git", ["merge", "--squash", branch], {
             cwd: basePath,
             stdio: ["ignore", "pipe", "pipe"],
             encoding: "utf-8",
+            env: GIT_NO_PROMPT_ENV,
         });
         return { success: true, conflicts: [] };
     }