gsd-pi 2.79.0 → 2.80.0-dev.4ea7d80e7

package/dist/resources/extensions/gsd/unit-context-manifest.js

@@ -137,6 +137,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "research",
         tools: TOOLS_PLANNING,
         artifacts: {
             // Phase 3 migration (#4782): matches today's actual
@@ -153,6 +154,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "planning",
         tools: TOOLS_PLANNING,
         artifacts: {
             inline: ["project", "requirements", "decisions", "milestone-research", "templates"],
@@ -167,6 +169,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "interview",
         tools: TOOLS_PLANNING,
         artifacts: {
             inline: ["project", "requirements", "decisions", "milestone-context", "templates"],
@@ -181,6 +184,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: false,
         preferences: "active-only",
+        contextMode: "verification",
         // planning-dispatch: validation is a verification-fan-out unit. It reads
         // the milestone surface and dispatches reviewer/security/tester subagents
         // to report findings without touching user source. Mirrors
@@ -199,6 +203,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: false,
         preferences: "active-only",
+        contextMode: "verification",
         // planning-dispatch: completion is a high-leverage place to fan out to
         // reviewer / security / tester subagents. They read the diff and report
         // findings; they do not write user source. Write isolation to .gsd/ is
@@ -221,6 +226,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "research",
         tools: TOOLS_PLANNING,
         artifacts: {
             inline: ["roadmap", "milestone-research", "dependency-summaries", "templates"],
@@ -235,6 +241,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "planning",
         // planning-dispatch: allows subagent dispatch so the planner can fan out
         // to scout for codebase recon and to planner/decompose-style specialists
         // for sub-decomposition. Write-isolation to .gsd/ is preserved.
@@ -252,6 +259,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "planning",
         // See plan-slice — same rationale: dispatch to scout/planner-style
         // specialists during refinement is materially better than re-doing recon
         // inline.
@@ -269,6 +277,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "planning",
         tools: TOOLS_PLANNING,
         artifacts: {
             inline: ["slice-plan", "slice-research", "dependency-summaries", "prior-task-summaries", "templates"],
@@ -283,6 +292,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: false,
         preferences: "active-only",
+        contextMode: "verification",
         // See complete-milestone — same rationale: dispatch to reviewer / security /
         // tester subagents to fan out review work without bloating this unit's
         // context.
@@ -304,6 +314,7 @@ export const UNIT_MANIFESTS = {
         memory: "critical-only",
         codebaseMap: false,
         preferences: "none",
+        contextMode: "planning",
         tools: TOOLS_PLANNING,
         artifacts: {
             // Phase 2 pilot (#4782): manifest now matches today's actual
@@ -322,6 +333,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "execution",
         tools: TOOLS_ALL,
         artifacts: {
             inline: ["task-plan", "slice-plan", "prior-task-summaries", "templates"],
@@ -336,6 +348,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "execution",
         tools: TOOLS_ALL,
         artifacts: {
             inline: ["slice-plan", "prior-task-summaries", "templates"],
@@ -351,6 +364,7 @@ export const UNIT_MANIFESTS = {
         memory: "critical-only",
         codebaseMap: false,
         preferences: "active-only",
+        contextMode: "verification",
         tools: TOOLS_PLANNING,
         artifacts: {
             // Phase 3 migration (#4782): manifest matches today's actual
@@ -369,6 +383,7 @@ export const UNIT_MANIFESTS = {
         memory: "critical-only",
         codebaseMap: false,
         preferences: "active-only",
+        contextMode: "verification",
         tools: TOOLS_PLANNING,
         artifacts: {
             inline: ["slice-plan", "prior-task-summaries"],
@@ -383,6 +398,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "docs",
         tools: TOOLS_DOCS,
         artifacts: {
             inline: ["project", "requirements", "decisions", "templates"],
@@ -401,6 +417,7 @@ export const UNIT_MANIFESTS = {
         memory: "none",
         codebaseMap: false,
         preferences: "none",
+        contextMode: "none",
         tools: TOOLS_PLANNING,
         artifacts: {
             inline: [],
@@ -418,6 +435,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "interview",
         tools: TOOLS_PLANNING,
         artifacts: {
             inline: ["templates"],
@@ -434,6 +452,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "interview",
         tools: TOOLS_PLANNING,
         artifacts: {
             inline: ["project", "templates"],
@@ -450,6 +469,7 @@ export const UNIT_MANIFESTS = {
         memory: "none",
         codebaseMap: false,
         preferences: "none",
+        contextMode: "none",
         tools: TOOLS_PLANNING,
         artifacts: {
             inline: [],
@@ -468,6 +488,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "research",
         tools: { mode: "planning-dispatch", allowedSubagents: ["scout"] },
         artifacts: {
             inline: ["project", "requirements", "templates"],

package/dist/resources/extensions/gsd/uok/audit.js

@@ -1,3 +1,4 @@
+// GSD2 UOK Audit Events and DB-First Projection Writes
 import { appendFileSync, closeSync, existsSync, mkdirSync, openSync } from "node:fs";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -5,6 +6,7 @@ import { isStaleWrite } from "../auto/turn-epoch.js";
 import { withFileLockSync } from "../file-lock.js";
 import { gsdRoot } from "../paths.js";
 import { isDbAvailable, insertAuditEvent } from "../gsd-db.js";
+import { CURRENT_UOK_CONTRACT_VERSION, validateAuditEvent } from "./contracts.js";
 function auditLogPath(basePath) {
     return join(gsdRoot(basePath), "audit", "events.jsonl");
 }
@@ -13,6 +15,7 @@ function ensureAuditDir(basePath) {
 }
 export function buildAuditEnvelope(args) {
     return {
+        version: CURRENT_UOK_CONTRACT_VERSION,
         eventId: randomUUID(),
         traceId: args.traceId,
         turnId: args.turnId,
@@ -27,6 +30,25 @@ export function emitUokAuditEvent(basePath, event) {
     // Drop writes from a turn superseded by timeout recovery / cancellation.
     if (isStaleWrite("uok-audit"))
         return;
+    const validation = validateAuditEvent(event);
+    if (!validation.ok) {
+        throw new Error(`Invalid UOK audit event: ${validation.issues.map((issue) => `${issue.path}: ${issue.message}`).join("; ")}`);
+    }
+    const canonical = validation.value;
+    if (isDbAvailable()) {
+        try {
+            insertAuditEvent({
+                ...canonical,
+                payload: {
+                    ...canonical.payload,
+                    contractVersion: canonical.version ?? CURRENT_UOK_CONTRACT_VERSION,
+                },
+            });
+        }
+        catch (err) {
+            throw new Error(`DB authoritative audit write failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     try {
         ensureAuditDir(basePath);
         const path = auditLogPath(basePath);
@@ -39,18 +61,10 @@ export function emitUokAuditEvent(basePath, event) {
         // POSIX O_APPEND atomicity still protects small line writes, so skipping
         // the lock rather than stalling orchestration is the correct tradeoff.
         withFileLockSync(path, () => {
-            appendFileSync(path, `${JSON.stringify(event)}\n`, "utf-8");
+            appendFileSync(path, `${JSON.stringify(canonical)}\n`, "utf-8");
         }, { onLocked: "skip" });
     }
     catch {
         // Best-effort: audit writes must never break orchestration.
     }
-    if (!isDbAvailable())
-        return;
-    try {
-        insertAuditEvent(event);
-    }
-    catch {
-        // Projection failures are non-fatal while legacy readers are still active.
-    }
 }

package/dist/resources/extensions/gsd/uok/contracts.js

@@ -1 +1,69 @@
-export {};
+// GSD2 UOK Contract Types and Versioning
+export const CURRENT_UOK_CONTRACT_VERSION = "1";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeVersion(value) {
+    return value === CURRENT_UOK_CONTRACT_VERSION ? CURRENT_UOK_CONTRACT_VERSION : "0";
+}
+function requireString(value, key, issues) {
+    if (typeof value[key] !== "string" || value[key] === "") {
+        issues.push({ path: key, message: `${key} must be a non-empty string` });
+    }
+}
+function requireRecord(value, key, issues) {
+    if (!isRecord(value[key])) {
+        issues.push({ path: key, message: `${key} must be an object` });
+    }
+}
+export function normalizeTurnResult(value) {
+    return { ...value, version: normalizeVersion(value.version) };
+}
+export function normalizeDispatchEnvelope(value) {
+    return { ...value, version: normalizeVersion(value.version) };
+}
+export function normalizeAuditEvent(value) {
+    return { ...value, version: normalizeVersion(value.version) };
+}
+export function validateTurnResult(value) {
+    const normalized = normalizeTurnResult(value);
+    const record = normalized;
+    const issues = [];
+    requireString(record, "traceId", issues);
+    requireString(record, "turnId", issues);
+    if (!Number.isInteger(record.iteration)) {
+        issues.push({ path: "iteration", message: "iteration must be an integer" });
+    }
+    requireString(record, "status", issues);
+    requireString(record, "failureClass", issues);
+    if (!Array.isArray(record.phaseResults)) {
+        issues.push({ path: "phaseResults", message: "phaseResults must be an array" });
+    }
+    requireString(record, "startedAt", issues);
+    requireString(record, "finishedAt", issues);
+    return { ok: issues.length === 0, value: normalized, issues };
+}
+export function validateDispatchEnvelope(value) {
+    const normalized = normalizeDispatchEnvelope(value);
+    const record = normalized;
+    const issues = [];
+    requireString(record, "action", issues);
+    requireRecord(record, "reason", issues);
+    if (isRecord(record.reason)) {
+        requireString(record.reason, "reasonCode", issues);
+        requireString(record.reason, "summary", issues);
+    }
+    return { ok: issues.length === 0, value: normalized, issues };
+}
+export function validateAuditEvent(value) {
+    const normalized = normalizeAuditEvent(value);
+    const record = normalized;
+    const issues = [];
+    requireString(record, "eventId", issues);
+    requireString(record, "traceId", issues);
+    requireString(record, "category", issues);
+    requireString(record, "type", issues);
+    requireString(record, "ts", issues);
+    requireRecord(record, "payload", issues);
+    return { ok: issues.length === 0, value: normalized, issues };
+}

package/dist/resources/extensions/gsd/uok/dispatch-envelope.js

@@ -1,5 +1,8 @@
+// GSD2 UOK Dispatch Envelope Builder
+import { CURRENT_UOK_CONTRACT_VERSION } from "./contracts.js";
 export function buildDispatchEnvelope(input) {
     return {
+        version: CURRENT_UOK_CONTRACT_VERSION,
         action: input.action,
         nodeKind: input.node?.kind,
         unitType: input.unitType,

package/dist/resources/extensions/gsd/uok/kernel.js

@@ -5,6 +5,7 @@ import { buildAuditEnvelope, emitUokAuditEvent } from "./audit.js";
 import { setUnifiedAuditEnabled } from "./audit-toggle.js";
 import { resolveUokFlags } from "./flags.js";
 import { createTurnObserver } from "./loop-adapter.js";
+import { incrementLegacyTelemetry } from "../legacy-telemetry.js";
 function parityLogPath(basePath) {
     return join(gsdRoot(basePath), "runtime", "uok-parity.jsonl");
 }
@@ -27,9 +28,13 @@ export async function runAutoLoopWithUok(args) {
     const prefs = deps.loadEffectiveGSDPreferences()?.preferences;
     const flags = resolveUokFlags(prefs);
     setUnifiedAuditEnabled(flags.auditUnified);
+    const pathLabel = resolveKernelPathLabel(flags);
+    if (pathLabel !== "uok-kernel") {
+        incrementLegacyTelemetry("legacy.uokFallbackUsed");
+    }
     writeParityEvent(s.basePath, {
         ts: new Date().toISOString(),
-        path: resolveKernelPathLabel(flags),
+        path: pathLabel,
         flags,
         phase: "enter",
     });
@@ -65,7 +70,7 @@ export async function runAutoLoopWithUok(args) {
         }
         writeParityEvent(s.basePath, {
             ts: new Date().toISOString(),
-            path: resolveKernelPathLabel(flags),
+            path: pathLabel,
             flags,
             phase: "exit",
             status: "ok",
@@ -74,7 +79,7 @@ export async function runAutoLoopWithUok(args) {
     catch (err) {
         writeParityEvent(s.basePath, {
             ts: new Date().toISOString(),
-            path: resolveKernelPathLabel(flags),
+            path: pathLabel,
             flags,
             phase: "exit",
             status: "error",

package/dist/resources/extensions/gsd/uok/loop-adapter.js

@@ -1,3 +1,5 @@
+// GSD2 UOK Turn Observer and DB-Backed Lifecycle Emission
+import { CURRENT_UOK_CONTRACT_VERSION, validateTurnResult } from "./contracts.js";
 import { buildAuditEnvelope, emitUokAuditEvent } from "./audit.js";
 import { writeTurnCloseoutGitRecord, writeTurnGitTransaction } from "./gitops.js";
 import { acquireWriterToken, nextWriteRecord, releaseWriterToken } from "./writer.js";
@@ -115,46 +117,59 @@ export function createTurnObserver(options) {
             }
         },
         onTurnResult(result) {
-            const merged = {
-                ...result,
-                phaseResults: result.phaseResults.length > 0 ? result.phaseResults : [...phaseResults],
+            const cleanup = () => {
+                if (writerToken) {
+                    releaseWriterToken(options.basePath, writerToken);
+                }
+                writerToken = null;
+                current = null;
+                phaseResults.length = 0;
             };
-            if (options.enableAudit) {
-                emitUokAuditEvent(options.basePath, buildAuditEnvelope({
-                    traceId: merged.traceId,
-                    turnId: merged.turnId,
-                    category: "orchestration",
-                    type: "turn-result",
-                    payload: nextSequenceMetadata("audit", "append", {
+            try {
+                const merged = {
+                    ...result,
+                    version: CURRENT_UOK_CONTRACT_VERSION,
+                    phaseResults: Array.isArray(result.phaseResults) && result.phaseResults.length > 0 ? result.phaseResults : [...phaseResults],
+                };
+                const validation = validateTurnResult(merged);
+                if (!validation.ok) {
+                    throw new Error(`Invalid UOK turn result: ${validation.issues.map((issue) => `${issue.path}: ${issue.message}`).join("; ")}`);
+                }
+                if (options.enableAudit) {
+                    emitUokAuditEvent(options.basePath, buildAuditEnvelope({
+                        traceId: validation.value.traceId,
+                        turnId: validation.value.turnId,
+                        category: "orchestration",
+                        type: "turn-result",
+                        payload: nextSequenceMetadata("audit", "append", {
+                            contractVersion: validation.value.version,
+                            unitType: validation.value.unitType,
+                            unitId: validation.value.unitId,
+                            status: validation.value.status,
+                            failureClass: validation.value.failureClass,
+                            error: validation.value.error,
+                            phaseCount: validation.value.phaseResults.length,
+                        }),
+                    }));
+                }
+                if (options.enableGitops) {
+                    const closeout = merged.closeout ?? {
+                        traceId: merged.traceId,
+                        turnId: merged.turnId,
                         unitType: merged.unitType,
                         unitId: merged.unitId,
                         status: merged.status,
                         failureClass: merged.failureClass,
-                        error: merged.error,
-                        phaseCount: merged.phaseResults.length,
-                    }),
-                }));
+                        gitAction: options.gitAction,
+                        gitPushed: options.gitPush,
+                        finishedAt: merged.finishedAt,
+                    };
+                    writeTurnCloseoutGitRecord(options.basePath, closeout, nextSequenceMetadata("gitops", "update", { action: "record" }));
+                }
             }
-            if (options.enableGitops) {
-                const closeout = merged.closeout ?? {
-                    traceId: merged.traceId,
-                    turnId: merged.turnId,
-                    unitType: merged.unitType,
-                    unitId: merged.unitId,
-                    status: merged.status,
-                    failureClass: merged.failureClass,
-                    gitAction: options.gitAction,
-                    gitPushed: options.gitPush,
-                    finishedAt: merged.finishedAt,
-                };
-                writeTurnCloseoutGitRecord(options.basePath, closeout, nextSequenceMetadata("gitops", "update", { action: "record" }));
+            finally {
+                cleanup();
             }
-            if (writerToken) {
-                releaseWriterToken(options.basePath, writerToken);
-            }
-            writerToken = null;
-            current = null;
-            phaseResults.length = 0;
         },
     };
 }

package/dist/resources/extensions/gsd/uok/plan-v2.js

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: UOK plan v2 graph compilation from GSD workflow state.
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot, resolveMilestoneFile, resolveSliceFile } from "../paths.js";

package/dist/resources/extensions/gsd/uok/timeline.js

@@ -0,0 +1,125 @@
+// GSD2 UOK Timeline Reconstruction from Authoritative DB Records
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { _getAdapter, isDbAvailable } from "../gsd-db.js";
+import { gsdRoot } from "../paths.js";
+function parseJsonRecord(value) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return value;
+    }
+    if (typeof value !== "string" || value.trim() === "")
+        return {};
+    try {
+        const parsed = JSON.parse(value);
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function matchesFilter(entry, filter) {
+    if (filter.traceId && entry.traceId !== filter.traceId)
+        return false;
+    if (filter.turnId && entry.turnId !== filter.turnId)
+        return false;
+    return true;
+}
+function byTimestamp(a, b) {
+    return a.ts.localeCompare(b.ts);
+}
+function readDbTimeline(filter) {
+    const db = _getAdapter();
+    if (!db)
+        return [];
+    const entries = [];
+    const where = [];
+    const params = {};
+    if (filter.traceId) {
+        where.push("trace_id = :trace_id");
+        params[":trace_id"] = filter.traceId;
+    }
+    if (filter.turnId) {
+        where.push("turn_id = :turn_id");
+        params[":turn_id"] = filter.turnId;
+    }
+    const suffix = where.length > 0 ? ` WHERE ${where.join(" AND ")}` : "";
+    const auditRows = db.prepare(`SELECT trace_id, turn_id, type, ts, payload_json FROM audit_events${suffix}`).all(params);
+    for (const row of auditRows) {
+        entries.push({
+            source: "audit_events",
+            ts: row.ts,
+            traceId: row.trace_id,
+            turnId: row.turn_id,
+            type: row.type,
+            payload: parseJsonRecord(row.payload_json),
+        });
+    }
+    const dispatchRows = db.prepare(`SELECT trace_id, turn_id, unit_type, unit_id, status, started_at, ended_at, exit_reason,
+            error_summary, retry_after_ms, attempt_n, max_attempts
+     FROM unit_dispatches${suffix}`).all(params);
+    for (const row of dispatchRows) {
+        entries.push({
+            source: "unit_dispatches",
+            ts: String(row.ended_at ?? row.started_at ?? ""),
+            traceId: String(row.trace_id ?? ""),
+            turnId: typeof row.turn_id === "string" ? row.turn_id : null,
+            type: `dispatch-${String(row.status ?? "unknown")}`,
+            payload: { ...row },
+        });
+    }
+    const gitRows = db.prepare(`SELECT trace_id, turn_id, unit_type, unit_id, stage, action, push, status, error,
+            metadata_json, updated_at
+     FROM turn_git_transactions${suffix}`).all(params);
+    for (const row of gitRows) {
+        entries.push({
+            source: "turn_git_transactions",
+            ts: String(row.updated_at ?? ""),
+            traceId: String(row.trace_id ?? ""),
+            turnId: typeof row.turn_id === "string" ? row.turn_id : null,
+            type: `gitops-${String(row.stage ?? "unknown")}`,
+            payload: {
+                ...row,
+                metadata: parseJsonRecord(row.metadata_json),
+            },
+        });
+    }
+    return entries.filter((entry) => entry.ts !== "").sort(byTimestamp);
+}
+function readJsonlTimeline(basePath, filter) {
+    const path = join(gsdRoot(basePath), "audit", "events.jsonl");
+    if (!existsSync(path))
+        return [];
+    return readFileSync(path, "utf-8")
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+        const event = parseJsonRecord(line);
+        const entry = {
+            source: "audit_jsonl",
+            ts: String(event.ts ?? ""),
+            traceId: typeof event.traceId === "string" ? event.traceId : undefined,
+            turnId: typeof event.turnId === "string" ? event.turnId : null,
+            type: String(event.type ?? "audit"),
+            payload: parseJsonRecord(event.payload),
+        };
+        return entry.ts && matchesFilter(entry, filter) ? entry : null;
+    })
+        .filter((entry) => entry !== null)
+        .sort(byTimestamp);
+}
+export function buildTurnTimeline(basePath, filter = {}) {
+    if (isDbAvailable()) {
+        return {
+            authoritative: "db",
+            degraded: false,
+            entries: readDbTimeline(filter),
+        };
+    }
+    return {
+        authoritative: "degraded-fallback",
+        degraded: true,
+        entries: readJsonlTimeline(basePath, filter),
+    };
+}

package/dist/resources/extensions/gsd/workflow-logger.js

@@ -3,13 +3,12 @@
 // Captures structured entries that the auto-loop can drain after each unit
 // to surface root causes for stuck loops, silent degradation, and blocked writes.
 // Error-severity entries are persisted to .gsd/audit-log.jsonl (sanitized) for
-// post-mortem analysis. Warnings are ephemeral (stderr + buffer only) to avoid
-// log amplification from expected-control-flow catch paths.
+// post-mortem analysis. Warnings persist to notifications and remain available
+// in the in-memory buffer, but are not printed to stderr.
 //
-// Stderr policy: every logWarning/logError call writes immediately to stderr
-// for terminal visibility. This is intentional — unlike debug-logger (which is
-// opt-in and zero-overhead when disabled), workflow-logger covers operational
-// warnings/errors that should always be visible. There is no disable flag.
+// Stderr policy: logError writes immediately to stderr for terminal visibility.
+// logWarning stays out of the TUI/stdout stream and is surfaced through the
+// notification store plus the auto-loop issue buffer.
 //
 // Singleton safety: _buffer is module-level and shared across all calls within
 // a process. The auto-loop must call _resetLogs() (or drainAndSummarize()) at
@@ -45,7 +44,8 @@ export function setStderrLoggingEnabled(enabled) {
 }
 // ─── Public API ─────────────────────────────────────────────────────────
 /**
- * Record a warning. Also writes to stderr for terminal visibility.
+ * Record a warning. Warnings are persisted to notifications and buffered for
+ * auto-loop issue summaries, but they are intentionally not written to stderr.
  */
 export function logWarning(component, message, context) {
     _push("warn", component, message, context);
@@ -189,10 +189,10 @@ function _push(severity, component, message, context) {
         message,
         ...(context ? { context } : {}),
     };
-    // Always forward to stderr so terminal watchers see it (see module header for policy)
-    const prefix = severity === "error" ? "ERROR" : "WARN";
-    const ctxStr = context ? ` ${JSON.stringify(context)}` : "";
-    _writeStderr(`[gsd:${component}] ${prefix}: ${message}${ctxStr}\n`);
+    if (severity === "error") {
+        const ctxStr = context ? ` ${JSON.stringify(context)}` : "";
+        _writeStderr(`[gsd:${component}] ERROR: ${message}${ctxStr}\n`);
+    }
     // Persist to notification store (both warnings and errors)
     try {
         appendNotification(`[${component}] ${message}`, severity === "error" ? "error" : "warning", "workflow-logger");
@@ -226,8 +226,8 @@ function _push(severity, component, message, context) {
         }
     }
     // Persist errors to .gsd/audit-log.jsonl so they survive context resets.
-    // Only error-severity entries are persisted — warnings are ephemeral (stderr + buffer)
-    // to avoid log amplification from expected-control-flow catch paths.
+    // Warnings are already persisted to notifications and buffered for the
+    // current auto-loop unit.
     if (_auditBasePath && severity === "error") {
         try {
             const auditDir = join(_auditBasePath, ".gsd");

package/dist/resources/extensions/gsd/workflow-manifest.js

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: State manifest snapshot and restore orchestration for GSD workflow data.
 import { _getAdapter, readTransaction, restoreManifest, } from "./gsd-db.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { readFileSync, existsSync, mkdirSync } from "node:fs";

package/dist/resources/extensions/gsd/workflow-projections.js

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Projection renderers for GSD workflow database rows.
 // GSD Extension — Projection Renderers (DB -> Markdown)
 // Renders PLAN.md, ROADMAP.md, SUMMARY.md, and STATE.md from database rows.
 // Projections are read-only views of engine state (Layer 3 of the architecture).