gsd-pi 2.80.0-dev.710c06e97 → 2.80.0-dev.8b3a59f5c

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-2743947d332c4ce6
+2b428bb01a7f0322

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

@@ -12,7 +12,7 @@ import { appendEvent } from "./workflow-events.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
-import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, refreshOpenDatabaseFromDisk } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, refreshOpenDatabaseFromDisk, getCompletedMilestoneTaskFileHints, getMilestoneCommitAttributionShas, recordMilestoneCommitAttribution } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
@@ -110,11 +110,11 @@ export function hasImplementationArtifacts(basePath, milestoneId) {
         // milestone commits instead of treating the self-diff as proof of no work.
         if (changedFiles.length === 0) {
             if (milestoneId && currentBranch === integrationBranch) {
-                const tagged = getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId);
-                if (!tagged.ok)
+                const milestoneEvidence = getChangedFilesFromMilestoneEvidence(basePath, milestoneId);
+                if (!milestoneEvidence.ok)
                     return "unknown";
-                if (tagged.matched)
-                    return classifyImplementationFiles(tagged.files);
+                if (milestoneEvidence.matched)
+                    return classifyImplementationFiles(milestoneEvidence.files);
             }
             if (currentBranch && currentBranch !== "HEAD")
                 return "absent";
@@ -129,11 +129,11 @@ export function hasImplementationArtifacts(basePath, milestoneId) {
         // insufficient; use the same milestone-tagged evidence fallback as the
         // self-diff retry path before declaring the milestone implementation-free.
         if (milestoneId) {
-            const tagged = getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId);
-            if (!tagged.ok)
+            const milestoneEvidence = getChangedFilesFromMilestoneEvidence(basePath, milestoneId);
+            if (!milestoneEvidence.ok)
                 return "unknown";
-            if (tagged.matched)
-                return classifyImplementationFiles(tagged.files);
+            if (milestoneEvidence.matched)
+                return classifyImplementationFiles(milestoneEvidence.files);
         }
         return "absent";
     }
@@ -163,6 +163,9 @@ function classifyImplementationFiles(files) {
 function isImplementationPath(file) {
     return !file.startsWith(".gsd/") && !file.startsWith(".gsd\\");
 }
+function normalizeRepoPath(file) {
+    return file.trim().replace(/\\/g, "/").replace(/^\.\/+/, "");
+}
 /**
  * Detect the main/master branch name.
  */
@@ -256,6 +259,125 @@ function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
         files: [...new Set([...scoped.files, ...unscoped.files])],
     };
 }
+function getChangedFilesFromMilestoneEvidence(basePath, milestoneId) {
+    const tagged = getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId);
+    if (!tagged.ok)
+        return tagged;
+    if (tagged.matched && classifyImplementationFiles(tagged.files) === "present")
+        return tagged;
+    const attributed = getChangedFilesFromAttributedMilestoneCommits(basePath, milestoneId);
+    if (!attributed.ok)
+        return tagged.matched ? tagged : attributed;
+    if (attributed.matched && classifyImplementationFiles(attributed.files) === "present")
+        return attributed;
+    const backfilled = backfillChangedFilesFromUntaggedMilestoneCommits(basePath, milestoneId);
+    if (!backfilled.ok)
+        return tagged.matched ? tagged : attributed.matched ? attributed : backfilled;
+    if (!backfilled.matched) {
+        if (tagged.matched)
+            return tagged;
+        return attributed.matched ? attributed : backfilled;
+    }
+    return {
+        ok: true,
+        matched: true,
+        files: [...new Set([...tagged.files, ...attributed.files, ...backfilled.files])],
+    };
+}
+function getChangedFilesFromAttributedMilestoneCommits(basePath, milestoneId) {
+    try {
+        const shas = getMilestoneCommitAttributionShas(milestoneId);
+        if (shas.length === 0)
+            return { ok: true, matched: false, files: [] };
+        const files = new Set();
+        let matched = false;
+        for (const sha of shas) {
+            if (!isFullCommitSha(sha))
+                continue;
+            const commitFiles = getChangedFilesForCommit(basePath, sha);
+            if (commitFiles.length === 0)
+                continue;
+            matched = true;
+            for (const file of commitFiles)
+                files.add(file);
+        }
+        return { ok: true, matched, files: [...files] };
+    }
+    catch (e) {
+        logWarning("recovery", `milestone attribution scan failed: ${e.message}`);
+        return { ok: false, matched: false, files: [] };
+    }
+}
+function backfillChangedFilesFromUntaggedMilestoneCommits(basePath, milestoneId) {
+    try {
+        const milestone = getMilestone(milestoneId);
+        const milestoneStartedAt = milestone?.created_at ? Math.floor(Date.parse(milestone.created_at) / 1000) * 1000 : NaN;
+        if (!Number.isFinite(milestoneStartedAt))
+            return { ok: true, matched: false, files: [] };
+        const taskFileHints = getCompletedMilestoneTaskFileHints(milestoneId);
+        if (taskFileHints.length === 0)
+            return { ok: true, matched: false, files: [] };
+        const hintSet = new Set(taskFileHints.map(normalizeRepoPath).filter(Boolean));
+        if (hintSet.size === 0)
+            return { ok: true, matched: false, files: [] };
+        const records = getCommitRecords(basePath);
+        const files = new Set();
+        let matched = false;
+        for (const record of records) {
+            if (!isFullCommitSha(record.hash))
+                continue;
+            if (Date.parse(record.committedAt) < milestoneStartedAt)
+                continue;
+            if (record.parents.trim().split(/\s+/).filter(Boolean).length > 1)
+                continue;
+            if (commitMessageHasGsdTrailer(record.message))
+                continue;
+            const commitFiles = getChangedFilesForCommit(basePath, record.hash);
+            const implementationFiles = commitFiles.map(normalizeRepoPath).filter(isImplementationPath);
+            if (implementationFiles.length === 0)
+                continue;
+            if (!implementationFiles.some((file) => hintSet.has(file)))
+                continue;
+            matched = true;
+            for (const file of implementationFiles)
+                files.add(file);
+            recordMilestoneCommitAttribution({
+                commitSha: record.hash,
+                milestoneId,
+                source: "backfill",
+                confidence: 0.8,
+                files: implementationFiles,
+                createdAt: new Date().toISOString(),
+            });
+        }
+        return { ok: true, matched, files: [...files] };
+    }
+    catch (e) {
+        logWarning("recovery", `milestone attribution backfill failed: ${e.message}`);
+        return { ok: false, matched: false, files: [] };
+    }
+}
+function getCommitRecords(basePath) {
+    const logOutput = execFileSync("git", ["log", "--format=%H%x1f%P%x1f%cI%x1f%B%x1e", "HEAD"], {
+        cwd: basePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+    });
+    return logOutput
+        .split("\x1e")
+        .map((record) => record.trim())
+        .filter(Boolean)
+        .flatMap((record) => {
+        const parts = record.split("\x1f");
+        if (parts.length < 4)
+            return [];
+        const [hash, parents, committedAt, ...messageParts] = parts;
+        return [{ hash: hash.trim(), parents: parents.trim(), committedAt: committedAt.trim(), message: messageParts.join("\x1f") }];
+    });
+}
+function isFullCommitSha(value) {
+    return /^[0-9a-f]{40}$/i.test(value);
+}
 function scanGsdTaggedCommits(basePath, milestoneId, gitArgs) {
     try {
         const logOutput = execFileSync("git", [...gitArgs], {

package/dist/resources/extensions/gsd/commands-extract-learnings.js

@@ -114,14 +114,19 @@ Using the \`write\` tool, persist the full structured report to
 LEARNINGS.md is the full, cited audit trail. Write it first — subsequent steps
 feed from its content.
 
-### Step 3 — Optionally pre-query the memory store for semantic duplicates
+### Step 3 — Run one bounded duplicate check
 
-Before persisting any extracted item in Steps 4–6, you may call
-\`memory_query\` with 2–3 keywords from the item to check whether the
-memory store already holds a semantically equivalent entry at high
-confidence. Skip those items in their respective steps. The memory store
-is the single source of truth for cross-session durable knowledge — no
-other persistence call is part of this flow.
+Before persisting extracted items in Steps 4–6, do at most one duplicate-check
+pass for the durable Decisions, Lessons, and Patterns from this milestone. Use
+the already-written LEARNINGS.md content and call \`memory_query\` once with a
+compact keyword summary for the whole batch. If that result clearly shows a
+semantically equivalent high-confidence memory for an item, mark only that item
+as already captured and skip it in its respective persistence step.
+
+Do not re-read milestone artefacts or repeat memory queries category-by-category
+after this point. The memory store is the single source of truth for
+cross-session durable knowledge — no other persistence call is part of this
+flow.
 
 ### Step 4 — Persist Patterns via \`capture_thought\`
 
@@ -160,11 +165,11 @@ later projection back to a human-visible decisions register stays lossless
 
 ### Step 7 — Deduplication rule (applies to Steps 4, 5, 6)
 
-Before each \`capture_thought\` call, optionally call \`memory_query\` with 2–3
-keywords from the entry. If a semantically equivalent memory is returned at
-high confidence, skip the capture entirely. Prefer skipping a near-duplicate
-over creating a second slightly-different row — redundancy degrades the
-signal.
+Use only the duplicate-check result from Step 3. If that bounded check returned
+a semantically equivalent memory at high confidence for an extracted item, skip
+the capture entirely. Otherwise, persist the item once via \`capture_thought\`.
+Prefer skipping a near-duplicate over creating a second slightly-different row
+— redundancy degrades the signal.
 
 ### Step 8 — Surprises stay only in LEARNINGS.md
 

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

@@ -294,6 +294,19 @@ export function createBaseSchemaObjects(db, hooks) {
       updated_at TEXT NOT NULL DEFAULT '',
       PRIMARY KEY (trace_id, turn_id, stage)
     )
+  `);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS milestone_commit_attributions (
+      commit_sha TEXT NOT NULL,
+      milestone_id TEXT NOT NULL,
+      slice_id TEXT DEFAULT NULL,
+      task_id TEXT DEFAULT NULL,
+      source TEXT NOT NULL DEFAULT 'recorded',
+      confidence REAL NOT NULL DEFAULT 1.0,
+      files_json TEXT NOT NULL DEFAULT '[]',
+      created_at TEXT NOT NULL DEFAULT '',
+      PRIMARY KEY (commit_sha, milestone_id)
+    )
   `);
     db.exec(`
     CREATE TABLE IF NOT EXISTS audit_events (
@@ -329,6 +342,7 @@ export function createBaseSchemaObjects(db, hooks) {
     db.exec("CREATE INDEX IF NOT EXISTS idx_gate_runs_turn ON gate_runs(trace_id, turn_id)");
     db.exec("CREATE INDEX IF NOT EXISTS idx_gate_runs_lookup ON gate_runs(milestone_id, slice_id, task_id, gate_id)");
     db.exec("CREATE INDEX IF NOT EXISTS idx_turn_git_tx_turn ON turn_git_transactions(trace_id, turn_id)");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_milestone_commit_attr_milestone ON milestone_commit_attributions(milestone_id)");
     db.exec("CREATE INDEX IF NOT EXISTS idx_audit_events_trace ON audit_events(trace_id, ts)");
     db.exec("CREATE INDEX IF NOT EXISTS idx_audit_events_turn ON audit_events(trace_id, turn_id, ts)");
     db.exec("CREATE VIEW IF NOT EXISTS active_decisions AS SELECT * FROM decisions WHERE superseded_by IS NULL");

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

@@ -363,6 +363,22 @@ export function applyMigrationV21StructuredMemories(db) {
 export function applyMigrationV23MilestoneQueue(db) {
     ensureColumn(db, "milestones", "sequence", "ALTER TABLE milestones ADD COLUMN sequence INTEGER DEFAULT 0");
 }
+export function applyMigrationV26MilestoneCommitAttributions(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS milestone_commit_attributions (
+      commit_sha TEXT NOT NULL,
+      milestone_id TEXT NOT NULL,
+      slice_id TEXT DEFAULT NULL,
+      task_id TEXT DEFAULT NULL,
+      source TEXT NOT NULL DEFAULT 'recorded',
+      confidence REAL NOT NULL DEFAULT 1.0,
+      files_json TEXT NOT NULL DEFAULT '[]',
+      created_at TEXT NOT NULL DEFAULT '',
+      PRIMARY KEY (commit_sha, milestone_id)
+    )
+  `);
+    db.exec("CREATE INDEX IF NOT EXISTS idx_milestone_commit_attr_milestone ON milestone_commit_attributions(milestone_id)");
+}
 export function applyMigrationV22QualityGateRepair(db, hooks) {
     const qgInfo = db.prepare("PRAGMA table_info(quality_gates)").all();
     const taskIdCol = qgInfo.find((r) => r["name"] === "task_id");

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

@@ -36,7 +36,7 @@ import { rowToActiveDecision, rowToActiveRequirement, rowToDecision, rowToRequir
 import { rowToGate } from "./db-gate-rows.js";
 import { rowToArtifact, rowToMilestone } from "./db-milestone-artifact-rows.js";
 import { backupDatabaseBeforeMigration } from "./db-migration-backup.js";
-import { applyMigrationV2Artifacts, applyMigrationV3Memories, applyMigrationV4DecisionMadeBy, applyMigrationV5HierarchyTables, applyMigrationV6SliceSummaries, applyMigrationV7Dependencies, applyMigrationV8PlanningFields, applyMigrationV9Ordering, applyMigrationV10ReplanTrigger, applyMigrationV11TaskPlanning, applyMigrationV12QualityGates, applyMigrationV13HotPathIndexes, applyMigrationV14SliceDependencies, applyMigrationV15AuditTables, applyMigrationV16EscalationSource, applyMigrationV17TaskEscalation, applyMigrationV18MemorySources, applyMigrationV19MemoryFts, applyMigrationV20MemoryRelations, applyMigrationV21StructuredMemories, applyMigrationV22QualityGateRepair, applyMigrationV23MilestoneQueue, } from "./db-migration-steps.js";
+import { applyMigrationV2Artifacts, applyMigrationV3Memories, applyMigrationV4DecisionMadeBy, applyMigrationV5HierarchyTables, applyMigrationV6SliceSummaries, applyMigrationV7Dependencies, applyMigrationV8PlanningFields, applyMigrationV9Ordering, applyMigrationV10ReplanTrigger, applyMigrationV11TaskPlanning, applyMigrationV12QualityGates, applyMigrationV13HotPathIndexes, applyMigrationV14SliceDependencies, applyMigrationV15AuditTables, applyMigrationV16EscalationSource, applyMigrationV17TaskEscalation, applyMigrationV18MemorySources, applyMigrationV19MemoryFts, applyMigrationV20MemoryRelations, applyMigrationV21StructuredMemories, applyMigrationV22QualityGateRepair, applyMigrationV23MilestoneQueue, applyMigrationV26MilestoneCommitAttributions, } from "./db-migration-steps.js";
 import { isMemoriesFtsAvailableSchema, tryCreateMemoriesFtsSchema } from "./db-memory-fts-schema.js";
 import { createDbOpenState } from "./db-open-state.js";
 import { createRuntimeKvTableV25 } from "./db-runtime-kv-schema.js";
@@ -52,7 +52,7 @@ const providerLoader = createSqliteProviderLoader({
     nodeVersion: process.versions.node,
     writeStderr: (message) => process.stderr.write(message),
 });
-export const SCHEMA_VERSION = 25;
+export const SCHEMA_VERSION = 26;
 function initSchema(db, fileBacked) {
     if (fileBacked)
         db.exec("PRAGMA journal_mode=WAL");
@@ -246,6 +246,10 @@ function migrateSchema(db) {
             createRuntimeKvTableV25(db);
             recordSchemaVersion(db, 25);
         }
+        if (currentVersion < 26) {
+            applyMigrationV26MilestoneCommitAttributions(db);
+            recordSchemaVersion(db, 26);
+        }
         db.exec("COMMIT");
     }
     catch (err) {
@@ -1158,6 +1162,47 @@ export function getSliceTasks(milestoneId, sliceId) {
     const rows = currentDb.prepare("SELECT * FROM tasks WHERE milestone_id = :mid AND slice_id = :sid ORDER BY sequence, id").all({ ":mid": milestoneId, ":sid": sliceId });
     return rows.map(rowToTask);
 }
+export function getCompletedMilestoneTaskFileHints(milestoneId) {
+    if (!currentDb)
+        return [];
+    const rows = currentDb.prepare(`SELECT files, key_files
+     FROM tasks
+     WHERE milestone_id = :mid AND status IN ('complete', 'done')`).all({ ":mid": milestoneId });
+    const hints = new Set();
+    for (const row of rows) {
+        for (const raw of [row["files"], row["key_files"]]) {
+            for (const file of parseStringArrayColumn(raw)) {
+                const normalized = normalizeRepoPath(file);
+                if (normalized)
+                    hints.add(normalized);
+            }
+        }
+    }
+    return [...hints];
+}
+function parseStringArrayColumn(raw) {
+    if (Array.isArray(raw))
+        return raw.filter((entry) => typeof entry === "string");
+    if (typeof raw !== "string")
+        return [];
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return [];
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed))
+            return parsed.filter((entry) => typeof entry === "string");
+        if (typeof parsed === "string")
+            return [parsed];
+    }
+    catch {
+        return trimmed.split(",");
+    }
+    return [];
+}
+function normalizeRepoPath(file) {
+    return file.trim().replace(/\\/g, "/").replace(/^\.\/+/, "");
+}
 // ─── ADR-011 Phase 2 escalation helpers ──────────────────────────────────
 /** Set pause-on-escalation state on a completed task. Mutually exclusive with awaiting_review. */
 export function setTaskEscalationPending(milestoneId, sliceId, taskId, artifactPath) {
@@ -1735,6 +1780,7 @@ export function deleteMilestone(milestoneId) {
         currentDb.prepare(`DELETE FROM replan_history WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
         currentDb.prepare(`DELETE FROM assessments WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
         currentDb.prepare(`DELETE FROM artifacts WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM milestone_commit_attributions WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
         currentDb.prepare(`DELETE FROM milestone_leases WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
         currentDb.prepare(`DELETE FROM milestones WHERE id = :mid`).run({ ":mid": milestoneId });
     });
@@ -1962,6 +2008,59 @@ export function upsertTurnGitTransaction(entry) {
         ":updated_at": entry.updatedAt,
     });
 }
+export function getMilestoneCommitAttributionShas(milestoneId) {
+    if (!currentDb)
+        return [];
+    const rows = currentDb.prepare(`SELECT commit_sha
+     FROM milestone_commit_attributions
+     WHERE milestone_id = :mid
+     ORDER BY created_at, commit_sha`).all({ ":mid": milestoneId });
+    return rows
+        .map((row) => typeof row["commit_sha"] === "string" ? row["commit_sha"] : "")
+        .filter(Boolean);
+}
+export function recordMilestoneCommitAttribution(entry) {
+    if (!currentDb)
+        return;
+    transaction(() => {
+        currentDb.prepare(`INSERT OR REPLACE INTO milestone_commit_attributions (
+        commit_sha, milestone_id, slice_id, task_id, source, confidence, files_json, created_at
+      ) VALUES (
+        :commit_sha, :milestone_id, :slice_id, :task_id, :source, :confidence, :files_json, :created_at
+      )`).run({
+            ":commit_sha": entry.commitSha,
+            ":milestone_id": entry.milestoneId,
+            ":slice_id": entry.sliceId ?? null,
+            ":task_id": entry.taskId ?? null,
+            ":source": entry.source,
+            ":confidence": entry.confidence,
+            ":files_json": JSON.stringify(entry.files),
+            ":created_at": entry.createdAt,
+        });
+        currentDb.prepare(`INSERT OR IGNORE INTO audit_events (
+        event_id, trace_id, turn_id, caused_by, category, type, ts, payload_json
+      ) VALUES (
+        :event_id, :trace_id, :turn_id, :caused_by, :category, :type, :ts, :payload_json
+      )`).run({
+            ":event_id": `milestone-commit-attribution:${entry.milestoneId}:${entry.commitSha}`,
+            ":trace_id": "milestone-commit-attribution",
+            ":turn_id": null,
+            ":caused_by": null,
+            ":category": "git",
+            ":type": "milestone-commit-attribution-recorded",
+            ":ts": entry.createdAt,
+            ":payload_json": JSON.stringify({
+                commitSha: entry.commitSha,
+                milestoneId: entry.milestoneId,
+                sliceId: entry.sliceId ?? null,
+                taskId: entry.taskId ?? null,
+                source: entry.source,
+                confidence: entry.confidence,
+                files: entry.files,
+            }),
+        });
+    });
+}
 export function insertAuditEvent(entry) {
     if (!currentDb)
         return;
@@ -2048,6 +2147,7 @@ export function clearEngineHierarchy() {
         currentDb.exec("DELETE FROM slice_dependencies");
         currentDb.exec("DELETE FROM assessments");
         currentDb.exec("DELETE FROM replan_history");
+        currentDb.exec("DELETE FROM milestone_commit_attributions");
         currentDb.exec("DELETE FROM tasks");
         currentDb.exec("DELETE FROM slices");
         currentDb.exec("DELETE FROM milestone_leases");