@workflow-cannon/workspace-kit 0.7.0 → 0.8.0

package/dist/modules/improvement/index.js

@@ -1,11 +1,12 @@
 import { queryLineageChain } from "../../core/lineage-store.js";
-import { runGenerateRecommendations } from "./generate-recommendations-runtime.js";
-import { resolveCadenceDecision, runSyncTranscripts } from "./transcript-sync-runtime.js";
+import { resolveSessionId } from "../../core/session-policy.js";
+import { getMaxRecommendationCandidatesPerRun, runGenerateRecommendations } from "./generate-recommendations-runtime.js";
+import { resolveCadenceDecision, resolveImprovementTranscriptConfig, runSyncTranscripts } from "./transcript-sync-runtime.js";
 import { loadImprovementState, saveImprovementState } from "./improvement-state.js";
 export const improvementModule = {
     registration: {
         id: "improvement",
-        version: "0.7.0",
+        version: "0.8.0",
         contractVersion: "1",
         capabilities: ["improvement"],
         dependsOn: ["task-engine", "planning"],
@@ -42,6 +43,11 @@ export const improvementModule = {
                     name: "ingest-transcripts",
                     file: "ingest-transcripts.md",
                     description: "Run transcript sync and recommendation generation in one flow."
+                },
+                {
+                    name: "transcript-automation-status",
+                    file: "transcript-automation-status.md",
+                    description: "Emit stable JSON status for transcript sync, ingest, and retry queue."
                 }
             ]
         }
@@ -72,8 +78,8 @@ export const improvementModule = {
                 archivePath: typeof args.archivePath === "string" ? args.archivePath : undefined
             };
             try {
-                const sync = await runSyncTranscripts(ctx, syncArgs);
                 const state = await loadImprovementState(ctx.workspacePath);
+                const sync = await runSyncTranscripts(ctx, syncArgs, state);
                 state.lastSyncRunAt = new Date().toISOString();
                 await saveImprovementState(ctx.workspacePath, state);
                 return {
@@ -95,21 +101,10 @@ export const improvementModule = {
             };
             const now = new Date();
             try {
-                const sync = await runSyncTranscripts(ctx, syncArgs);
                 const state = await loadImprovementState(ctx.workspacePath);
-                const improvement = ctx.effectiveConfig?.improvement && typeof ctx.effectiveConfig.improvement === "object"
-                    ? ctx.effectiveConfig.improvement
-                    : {};
-                const cadence = improvement.cadence && typeof improvement.cadence === "object"
-                    ? improvement.cadence
-                    : {};
-                const minIntervalMinutes = typeof cadence.minIntervalMinutes === "number" && Number.isFinite(cadence.minIntervalMinutes)
-                    ? Math.max(1, Math.floor(cadence.minIntervalMinutes))
-                    : 15;
-                const skipIfNoNewTranscripts = typeof cadence.skipIfNoNewTranscripts === "boolean"
-                    ? cadence.skipIfNoNewTranscripts
-                    : true;
-                const cadenceDecision = resolveCadenceDecision(now, state.lastIngestRunAt, minIntervalMinutes, sync.copied, skipIfNoNewTranscripts);
+                const sync = await runSyncTranscripts(ctx, syncArgs, state);
+                const cfg = resolveImprovementTranscriptConfig(ctx, syncArgs);
+                const cadenceDecision = resolveCadenceDecision(now, state.lastIngestRunAt, cfg.minIntervalMinutes, sync.copied, cfg.skipIfNoNewTranscripts);
                 state.lastSyncRunAt = now.toISOString();
                 const generate = cadenceDecision.shouldRunGenerate || args.forceGenerate === true || args.runGenerate === true;
                 let recommendations = null;
@@ -128,8 +123,8 @@ export const improvementModule = {
                     data: {
                         sync,
                         cadence: {
-                            minIntervalMinutes,
-                            skipIfNoNewTranscripts,
+                            minIntervalMinutes: cfg.minIntervalMinutes,
+                            skipIfNoNewTranscripts: cfg.skipIfNoNewTranscripts,
                             decision: cadenceDecision.reason
                         },
                         generatedRecommendations: recommendations
@@ -141,6 +136,46 @@ export const improvementModule = {
                 return { ok: false, code: "ingest-failed", message: msg };
             }
         }
+        if (command.name === "transcript-automation-status") {
+            const syncArgs = {
+                sourcePath: typeof args.sourcePath === "string" ? args.sourcePath : undefined,
+                archivePath: typeof args.archivePath === "string" ? args.archivePath : undefined
+            };
+            const state = await loadImprovementState(ctx.workspacePath);
+            const cfg = resolveImprovementTranscriptConfig(ctx, syncArgs);
+            return {
+                ok: true,
+                code: "transcript-automation-status",
+                message: "Transcript automation status",
+                data: {
+                    schemaVersion: 1,
+                    lastSyncRunAt: state.lastSyncRunAt,
+                    lastIngestRunAt: state.lastIngestRunAt,
+                    cadence: {
+                        minIntervalMinutes: cfg.minIntervalMinutes,
+                        skipIfNoNewTranscripts: cfg.skipIfNoNewTranscripts,
+                        maxRecommendationCandidatesPerRun: getMaxRecommendationCandidatesPerRun(ctx)
+                    },
+                    transcripts: {
+                        sourcePath: cfg.sourcePath || null,
+                        archivePath: cfg.archivePath,
+                        discoveryPaths: cfg.discoveryPaths,
+                        budgets: {
+                            maxFilesPerSync: cfg.maxFilesPerSync,
+                            maxBytesPerFile: cfg.maxBytesPerFile,
+                            maxTotalScanBytes: cfg.maxTotalScanBytes
+                        }
+                    },
+                    retryQueue: {
+                        pending: state.transcriptRetryQueue?.length ?? 0,
+                        entries: state.transcriptRetryQueue ?? []
+                    },
+                    policySession: {
+                        sessionId: resolveSessionId(process.env)
+                    }
+                }
+            };
+        }
         if (command.name === "query-lineage") {
             const taskId = typeof args.taskId === "string" ? args.taskId.trim() : "";
             if (!taskId) {

package/dist/modules/improvement/ingest.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { execFileSync } from "node:child_process";
 import crypto from "node:crypto";
 import { computeHeuristicConfidence, shouldAdmitRecommendation } from "./confidence.js";
+import { redactTranscriptSnippet } from "./transcript-redaction.js";
 function sha256Hex(s) {
     return crypto.createHash("sha256").update(s, "utf8").digest("hex");
 }
@@ -80,7 +81,7 @@ export async function ingestAgentTranscripts(workspacePath, transcriptsRootRel,
             evidenceKind: "transcript",
             evidenceKey,
             title: `Reduce friction hinted in transcript (${path.basename(rel)})`,
-            provenanceRefs: { transcriptPath: rel, sampleLine },
+            provenanceRefs: { transcriptPath: rel, sampleLine: redactTranscriptSnippet(sampleLine) },
             signals,
             confidence
         });

package/dist/modules/improvement/transcript-redaction.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Redact transcript-derived strings before they are persisted in task metadata or lineage.
+ */
+export declare function redactTranscriptSnippet(text: string, maxLen?: number): string;

package/dist/modules/improvement/transcript-redaction.js

@@ -0,0 +1,10 @@
+/**
+ * Redact transcript-derived strings before they are persisted in task metadata or lineage.
+ */
+export function redactTranscriptSnippet(text, maxLen = 160) {
+    let s = text.length > maxLen ? `${text.slice(0, maxLen)}…` : text;
+    s = s.replace(/\b(sk|pk|api|Bearer)[-_]?[a-zA-Z0-9]{12,}\b/gi, "[redacted-token]");
+    s = s.replace(/\b[A-Fa-f0-9]{32,}\b/g, "[redacted-hex]");
+    s = s.replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g, "[redacted-email]");
+    return s;
+}

package/dist/modules/improvement/transcript-sync-runtime.d.ts

@@ -1,24 +1,60 @@
 import type { ModuleLifecycleContext } from "../../contracts/module-contract.js";
+import type { ImprovementStateDocument } from "./improvement-state.js";
 export type TranscriptSyncArgs = {
     sourcePath?: string;
     archivePath?: string;
 };
+export type TranscriptSkipReason = "skipped-unchanged-hash" | "skipped-archive-conflict" | "skipped-file-too-large" | "skipped-budget-max-files" | "skipped-budget-total-bytes" | "skipped-read-error";
 export type TranscriptSyncResult = {
+    runId: string;
     sourcePath: string;
     archivePath: string;
+    discoveredFrom: string;
+    discoveryCandidatesTried: string[];
     scanned: number;
     copied: number;
     skippedExisting: number;
     skippedConflict: number;
+    skippedBudget: number;
+    skippedLargeFile: number;
     errors: Array<{
         file: string;
         code: string;
         message: string;
     }>;
     copiedFiles: string[];
+    skipReasons: Record<string, TranscriptSkipReason>;
+    budget: {
+        maxFilesPerSync: number;
+        maxBytesPerFile: number;
+        maxTotalScanBytes: number;
+        scanBytesUsed: number;
+    };
+    retryQueue: {
+        pending: number;
+        processedRetries: number;
+        droppedPermanentFailures: number;
+    };
 };
-export declare function runSyncTranscripts(ctx: ModuleLifecycleContext, args: TranscriptSyncArgs): Promise<TranscriptSyncResult>;
+type ImprovementTranscriptConfig = {
+    sourcePath: string;
+    archivePath: string;
+    minIntervalMinutes: number;
+    skipIfNoNewTranscripts: boolean;
+    maxFilesPerSync: number;
+    maxBytesPerFile: number;
+    maxTotalScanBytes: number;
+    discoveryPaths: string[];
+};
+export declare function resolveImprovementTranscriptConfig(ctx: ModuleLifecycleContext, args: TranscriptSyncArgs): ImprovementTranscriptConfig;
+export declare function resolveTranscriptSourceRoot(workspacePath: string, cfg: ImprovementTranscriptConfig, args: TranscriptSyncArgs): Promise<{
+    root: string;
+    discoveredFrom: string;
+    tried: string[];
+}>;
+export declare function runSyncTranscripts(ctx: ModuleLifecycleContext, args: TranscriptSyncArgs, state: ImprovementStateDocument, now?: Date): Promise<TranscriptSyncResult>;
 export declare function resolveCadenceDecision(now: Date, previousRunAtIso: string | null, minIntervalMinutes: number, copiedCount: number, skipIfNoNewTranscripts: boolean): {
     shouldRunGenerate: boolean;
     reason: string;
 };
+export {};

package/dist/modules/improvement/transcript-sync-runtime.js

@@ -1,7 +1,10 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { createHash } from "node:crypto";
-function resolveImprovementTranscriptConfig(ctx, args) {
+import { createHash, randomUUID } from "node:crypto";
+const DEFAULT_DISCOVERY_PATHS = [".cursor/agent-transcripts", ".vscode/agent-transcripts"];
+const MAX_RETRY_ATTEMPTS = 5;
+const INITIAL_BACKOFF_MS = 60_000;
+export function resolveImprovementTranscriptConfig(ctx, args) {
     const improvement = ctx.effectiveConfig?.improvement && typeof ctx.effectiveConfig.improvement === "object"
         ? ctx.effectiveConfig.improvement
         : {};
@@ -19,13 +22,63 @@ function resolveImprovementTranscriptConfig(ctx, args) {
         ? cadence.minIntervalMinutes
         : 15;
     const skipIfNoNewCfg = typeof cadence.skipIfNoNewTranscripts === "boolean" ? cadence.skipIfNoNewTranscripts : true;
+    const maxFilesCfg = typeof transcripts.maxFilesPerSync === "number" && Number.isFinite(transcripts.maxFilesPerSync)
+        ? Math.max(1, Math.floor(transcripts.maxFilesPerSync))
+        : 5000;
+    const maxBytesFileCfg = typeof transcripts.maxBytesPerFile === "number" && Number.isFinite(transcripts.maxBytesPerFile)
+        ? Math.max(1024, Math.floor(transcripts.maxBytesPerFile))
+        : 50_000_000;
+    const maxTotalScanCfg = typeof transcripts.maxTotalScanBytes === "number" && Number.isFinite(transcripts.maxTotalScanBytes)
+        ? Math.max(1024, Math.floor(transcripts.maxTotalScanBytes))
+        : 500_000_000;
+    let discoveryPaths = [];
+    if (Array.isArray(transcripts.discoveryPaths)) {
+        discoveryPaths = transcripts.discoveryPaths.filter((x) => typeof x === "string" && x.trim().length > 0);
+    }
+    if (discoveryPaths.length === 0) {
+        discoveryPaths = [...DEFAULT_DISCOVERY_PATHS];
+    }
     return {
-        sourcePath: sourcePathArg || sourcePathCfg || ".cursor/agent-transcripts",
+        sourcePath: sourcePathArg || sourcePathCfg || "",
         archivePath: archivePathArg || archivePathCfg || "agent-transcripts",
         minIntervalMinutes: Math.max(1, Math.floor(minIntervalCfg)),
-        skipIfNoNewTranscripts: skipIfNoNewCfg
+        skipIfNoNewTranscripts: skipIfNoNewCfg,
+        maxFilesPerSync: maxFilesCfg,
+        maxBytesPerFile: maxBytesFileCfg,
+        maxTotalScanBytes: maxTotalScanCfg,
+        discoveryPaths
     };
 }
+async function pathExists(abs) {
+    try {
+        await fs.access(abs);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveTranscriptSourceRoot(workspacePath, cfg, args) {
+    const sourcePathArg = typeof args.sourcePath === "string" ? args.sourcePath.trim() : "";
+    if (sourcePathArg) {
+        const root = path.resolve(workspacePath, sourcePathArg);
+        return { root, discoveredFrom: sourcePathArg, tried: [sourcePathArg] };
+    }
+    if (cfg.sourcePath) {
+        const root = path.resolve(workspacePath, cfg.sourcePath);
+        return { root, discoveredFrom: cfg.sourcePath, tried: [cfg.sourcePath] };
+    }
+    const tried = [];
+    for (const rel of cfg.discoveryPaths) {
+        tried.push(rel);
+        const abs = path.resolve(workspacePath, rel);
+        if (await pathExists(abs)) {
+            return { root: abs, discoveredFrom: rel, tried };
+        }
+    }
+    const fallback = path.resolve(workspacePath, ".cursor/agent-transcripts");
+    return { root: fallback, discoveredFrom: ".cursor/agent-transcripts (fallback)", tried };
+}
 async function listJsonlRelativePaths(root) {
     const out = [];
     async function walk(cur) {
@@ -43,23 +96,49 @@ async function listJsonlRelativePaths(root) {
     await walk(root);
     return out.sort((a, b) => a.localeCompare(b));
 }
+async function statSize(filePath) {
+    try {
+        const st = await fs.stat(filePath);
+        return st.size;
+    }
+    catch {
+        return null;
+    }
+}
 async function fileSha256(filePath) {
     const buf = await fs.readFile(filePath);
     return createHash("sha256").update(buf).digest("hex");
 }
-export async function runSyncTranscripts(ctx, args) {
+function nextBackoffMs(attempts) {
+    return INITIAL_BACKOFF_MS * 2 ** Math.max(0, attempts - 1);
+}
+export async function runSyncTranscripts(ctx, args, state, now = new Date()) {
     const cfg = resolveImprovementTranscriptConfig(ctx, args);
-    const sourceRoot = path.resolve(ctx.workspacePath, cfg.sourcePath);
+    const runId = randomUUID();
+    const { root: sourceRoot, discoveredFrom, tried: discoveryCandidatesTried } = await resolveTranscriptSourceRoot(ctx.workspacePath, cfg, args);
     const archiveRoot = path.resolve(ctx.workspacePath, cfg.archivePath);
     const result = {
+        runId,
         sourcePath: path.relative(ctx.workspacePath, sourceRoot) || ".",
         archivePath: path.relative(ctx.workspacePath, archiveRoot) || ".",
+        discoveredFrom,
+        discoveryCandidatesTried,
         scanned: 0,
         copied: 0,
         skippedExisting: 0,
         skippedConflict: 0,
+        skippedBudget: 0,
+        skippedLargeFile: 0,
         errors: [],
-        copiedFiles: []
+        copiedFiles: [],
+        skipReasons: {},
+        budget: {
+            maxFilesPerSync: cfg.maxFilesPerSync,
+            maxBytesPerFile: cfg.maxBytesPerFile,
+            maxTotalScanBytes: cfg.maxTotalScanBytes,
+            scanBytesUsed: 0
+        },
+        retryQueue: { pending: 0, processedRetries: 0, droppedPermanentFailures: 0 }
     };
     let files = [];
     try {
@@ -70,16 +149,113 @@ export async function runSyncTranscripts(ctx, args) {
         result.errors.push({
             file: result.sourcePath,
             code: "source-read-error",
-            message: msg
+            message: `${msg} (discovery tried: ${discoveryCandidatesTried.join(", ")})`
         });
         return result;
     }
-    result.scanned = files.length;
     await fs.mkdir(archiveRoot, { recursive: true });
+    const queue = state.transcriptRetryQueue ?? [];
+    const remainingRetries = [];
+    let scanBytes = 0;
+    for (const entry of queue) {
+        const due = new Date(entry.nextRetryAt).getTime() <= now.getTime();
+        if (!due) {
+            remainingRetries.push(entry);
+            continue;
+        }
+        if (entry.attempts >= MAX_RETRY_ATTEMPTS) {
+            result.retryQueue.droppedPermanentFailures += 1;
+            result.errors.push({
+                file: entry.relativePath,
+                code: "retry-exhausted",
+                message: entry.lastErrorMessage
+            });
+            continue;
+        }
+        const src = path.join(sourceRoot, entry.relativePath);
+        const dst = path.join(archiveRoot, entry.relativePath);
+        try {
+            await fs.mkdir(path.dirname(dst), { recursive: true });
+            const sz = await statSize(src);
+            if (sz !== null && sz > cfg.maxBytesPerFile) {
+                remainingRetries.push({
+                    ...entry,
+                    attempts: entry.attempts + 1,
+                    lastErrorCode: "file-too-large",
+                    lastErrorMessage: `size ${sz} exceeds maxBytesPerFile`,
+                    nextRetryAt: new Date(now.getTime() + nextBackoffMs(entry.attempts + 1)).toISOString()
+                });
+                continue;
+            }
+            if (sz !== null) {
+                scanBytes += sz;
+            }
+            const srcHash = await fileSha256(src);
+            let dstHash = null;
+            try {
+                dstHash = await fileSha256(dst);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    throw error;
+                }
+            }
+            if (dstHash === srcHash) {
+                result.retryQueue.processedRetries += 1;
+                continue;
+            }
+            if (dstHash && dstHash !== srcHash) {
+                remainingRetries.push({
+                    ...entry,
+                    attempts: entry.attempts + 1,
+                    lastErrorCode: "archive-conflict",
+                    lastErrorMessage: "destination exists with different content",
+                    nextRetryAt: new Date(now.getTime() + nextBackoffMs(entry.attempts + 1)).toISOString()
+                });
+                continue;
+            }
+            await fs.copyFile(src, dst);
+            result.copied += 1;
+            result.copiedFiles.push(entry.relativePath);
+            result.retryQueue.processedRetries += 1;
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            remainingRetries.push({
+                ...entry,
+                attempts: entry.attempts + 1,
+                lastErrorCode: "copy-error",
+                lastErrorMessage: msg,
+                nextRetryAt: new Date(now.getTime() + nextBackoffMs(entry.attempts + 1)).toISOString()
+            });
+        }
+    }
+    let budgetFiles = 0;
     for (const rel of files) {
+        if (budgetFiles >= cfg.maxFilesPerSync) {
+            result.skippedBudget += 1;
+            result.skipReasons[rel] = "skipped-budget-max-files";
+            continue;
+        }
         const src = path.join(sourceRoot, rel);
         const dst = path.join(archiveRoot, rel);
+        budgetFiles += 1;
+        result.scanned += 1;
         try {
+            const sz = await statSize(src);
+            if (sz !== null && sz > cfg.maxBytesPerFile) {
+                result.skippedLargeFile += 1;
+                result.skipReasons[rel] = "skipped-file-too-large";
+                continue;
+            }
+            if (sz !== null && scanBytes + sz > cfg.maxTotalScanBytes) {
+                result.skippedBudget += 1;
+                result.skipReasons[rel] = "skipped-budget-total-bytes";
+                continue;
+            }
+            if (sz !== null) {
+                scanBytes += sz;
+            }
             await fs.mkdir(path.dirname(dst), { recursive: true });
             const srcHash = await fileSha256(src);
             let dstHash = null;
@@ -93,10 +269,12 @@ export async function runSyncTranscripts(ctx, args) {
             }
             if (dstHash === srcHash) {
                 result.skippedExisting += 1;
+                result.skipReasons[rel] = "skipped-unchanged-hash";
                 continue;
             }
             if (dstHash && dstHash !== srcHash) {
                 result.skippedConflict += 1;
+                result.skipReasons[rel] = "skipped-archive-conflict";
                 continue;
             }
             await fs.copyFile(src, dst);
@@ -106,8 +284,19 @@ export async function runSyncTranscripts(ctx, args) {
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
             result.errors.push({ file: rel, code: "copy-error", message: msg });
+            remainingRetries.push({
+                relativePath: rel,
+                attempts: 1,
+                lastErrorCode: "copy-error",
+                lastErrorMessage: msg,
+                nextRetryAt: new Date(now.getTime() + INITIAL_BACKOFF_MS).toISOString()
+            });
+            result.skipReasons[rel] = "skipped-read-error";
         }
     }
+    result.budget.scanBytesUsed = scanBytes;
+    state.transcriptRetryQueue = remainingRetries;
+    result.retryQueue.pending = remainingRetries.length;
     result.copiedFiles.sort((a, b) => a.localeCompare(b));
     return result;
 }

package/dist/modules/index.d.ts

@@ -5,5 +5,5 @@ export { improvementModule } from "./improvement/index.js";
 export { computeHeuristicConfidence, HEURISTIC_1_ADMISSION_THRESHOLD, shouldAdmitRecommendation, type ConfidenceResult, type ConfidenceSignals, type EvidenceKind } from "./improvement/confidence.js";
 export { workspaceConfigModule } from "./workspace-config/index.js";
 export { planningModule } from "./planning/index.js";
-export { taskEngineModule, TaskStore, TransitionService, TaskEngineError, TransitionValidator, isTransitionAllowed, getTransitionAction, resolveTargetState, getAllowedTransitionsFrom, stateValidityGuard, dependencyCheckGuard, generateTasksMd, syncTaskHeadingsInMarkdown, importTasksFromMarkdown, getNextActions } from "./task-engine/index.js";
+export { taskEngineModule, TaskStore, TransitionService, TaskEngineError, TransitionValidator, isTransitionAllowed, getTransitionAction, resolveTargetState, getAllowedTransitionsFrom, stateValidityGuard, dependencyCheckGuard, getNextActions } from "./task-engine/index.js";
 export type { TaskEntity, TaskStatus, TaskPriority, TaskStoreDocument, TransitionEvidence, TransitionGuard, TransitionContext, GuardResult, TaskEngineErrorCode, TaskAdapter, TaskAdapterCapability, NextActionSuggestion, BlockingAnalysisEntry } from "./task-engine/index.js";

package/dist/modules/index.js

@@ -4,4 +4,4 @@ export { improvementModule } from "./improvement/index.js";
 export { computeHeuristicConfidence, HEURISTIC_1_ADMISSION_THRESHOLD, shouldAdmitRecommendation } from "./improvement/confidence.js";
 export { workspaceConfigModule } from "./workspace-config/index.js";
 export { planningModule } from "./planning/index.js";
-export { taskEngineModule, TaskStore, TransitionService, TaskEngineError, TransitionValidator, isTransitionAllowed, getTransitionAction, resolveTargetState, getAllowedTransitionsFrom, stateValidityGuard, dependencyCheckGuard, generateTasksMd, syncTaskHeadingsInMarkdown, importTasksFromMarkdown, getNextActions } from "./task-engine/index.js";
+export { taskEngineModule, TaskStore, TransitionService, TaskEngineError, TransitionValidator, isTransitionAllowed, getTransitionAction, resolveTargetState, getAllowedTransitionsFrom, stateValidityGuard, dependencyCheckGuard, getNextActions } from "./task-engine/index.js";

package/dist/modules/task-engine/index.d.ts

@@ -3,7 +3,5 @@ export type { TaskEntity, TaskStatus, TaskPriority, TaskStoreDocument, Transitio
 export { TaskStore } from "./store.js";
 export { TransitionService } from "./service.js";
 export { TaskEngineError, TransitionValidator, isTransitionAllowed, getTransitionAction, resolveTargetState, getAllowedTransitionsFrom, stateValidityGuard, dependencyCheckGuard } from "./transitions.js";
-export { generateTasksMd, syncTaskHeadingsInMarkdown } from "./generator.js";
-export { importTasksFromMarkdown } from "./importer.js";
 export { getNextActions } from "./suggestions.js";
 export declare const taskEngineModule: WorkflowModule;

package/dist/modules/task-engine/index.js

@@ -1,16 +1,11 @@
-import path from "node:path";
-import fs from "node:fs/promises";
+import { maybeSpawnTranscriptHookAfterCompletion } from "../../core/transcript-completion-hook.js";
 import { TaskStore } from "./store.js";
 import { TransitionService } from "./service.js";
 import { TaskEngineError } from "./transitions.js";
-import { generateTasksMd, syncTaskHeadingsInMarkdown } from "./generator.js";
-import { importTasksFromMarkdown } from "./importer.js";
 import { getNextActions } from "./suggestions.js";
 export { TaskStore } from "./store.js";
 export { TransitionService } from "./service.js";
 export { TaskEngineError, TransitionValidator, isTransitionAllowed, getTransitionAction, resolveTargetState, getAllowedTransitionsFrom, stateValidityGuard, dependencyCheckGuard } from "./transitions.js";
-export { generateTasksMd, syncTaskHeadingsInMarkdown } from "./generator.js";
-export { importTasksFromMarkdown } from "./importer.js";
 export { getNextActions } from "./suggestions.js";
 function taskStorePath(ctx) {
     const tasks = ctx.effectiveConfig?.tasks;
@@ -61,16 +56,6 @@ export const taskEngineModule = {
                     file: "get-ready-queue.md",
                     description: "Get ready tasks sorted by priority."
                 },
-                {
-                    name: "import-tasks",
-                    file: "import-tasks.md",
-                    description: "One-time import from TASKS.md into engine state."
-                },
-                {
-                    name: "generate-tasks-md",
-                    file: "generate-tasks-md.md",
-                    description: "Generate read-only TASKS.md from engine state."
-                },
                 {
                     name: "get-next-actions",
                     file: "get-next-actions.md",
@@ -113,6 +98,9 @@ export const taskEngineModule = {
             try {
                 const service = new TransitionService(store);
                 const result = await service.runTransition({ taskId, action, actor });
+                if (result.evidence.toState === "completed") {
+                    maybeSpawnTranscriptHookAfterCompletion(ctx.workspacePath, (ctx.effectiveConfig ?? {}));
+                }
                 return {
                     ok: true,
                     code: "transition-applied",
@@ -190,68 +178,6 @@ export const taskEngineModule = {
                 data: { tasks: ready, count: ready.length }
             };
         }
-        if (command.name === "import-tasks") {
-            const sourcePath = typeof args.sourcePath === "string"
-                ? path.resolve(ctx.workspacePath, args.sourcePath)
-                : path.resolve(ctx.workspacePath, "docs/maintainers/TASKS.md");
-            try {
-                const result = await importTasksFromMarkdown(sourcePath);
-                store.replaceAllTasks(result.tasks);
-                await store.save();
-                return {
-                    ok: true,
-                    code: "tasks-imported",
-                    message: `Imported ${result.imported} tasks (${result.skipped} skipped)`,
-                    data: {
-                        imported: result.imported,
-                        skipped: result.skipped,
-                        errors: result.errors
-                    }
-                };
-            }
-            catch (err) {
-                if (err instanceof TaskEngineError) {
-                    return { ok: false, code: err.code, message: err.message };
-                }
-                return {
-                    ok: false,
-                    code: "import-parse-error",
-                    message: err.message
-                };
-            }
-        }
-        if (command.name === "generate-tasks-md") {
-            const outputPath = typeof args.outputPath === "string"
-                ? path.resolve(ctx.workspacePath, args.outputPath)
-                : path.resolve(ctx.workspacePath, "docs/maintainers/TASKS.md");
-            const tasks = store.getAllTasks();
-            const fallbackMarkdown = generateTasksMd(tasks);
-            let markdown = fallbackMarkdown;
-            const preserveStructure = args.preserveStructure !== false;
-            try {
-                if (preserveStructure) {
-                    const existing = await fs.readFile(outputPath, "utf8").catch(() => undefined);
-                    if (typeof existing === "string" && existing.length > 0) {
-                        markdown = syncTaskHeadingsInMarkdown(existing, tasks);
-                    }
-                }
-                await fs.mkdir(path.dirname(outputPath), { recursive: true });
-                await fs.writeFile(outputPath, markdown, "utf8");
-            }
-            catch (err) {
-                return {
-                    ok: false,
-                    code: "storage-write-error",
-                    message: `Failed to write TASKS.md: ${err.message}`
-                };
-            }
-            return {
-                ok: true,
-                code: "tasks-md-generated",
-                message: `Generated TASKS.md with ${tasks.length} tasks`,
-                data: { outputPath, taskCount: tasks.length }
-            };
-        }
         if (command.name === "get-next-actions") {
             const tasks = store.getAllTasks();
             const suggestion = getNextActions(tasks);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow-cannon/workspace-kit",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "private": false,
   "packageManager": "pnpm@10.0.0",
   "license": "MIT",
@@ -31,7 +31,10 @@
     "generate-runtime-diagnostics": "node scripts/generate-runtime-diagnostics.mjs",
     "prune-evidence": "node scripts/prune-evidence.mjs",
     "phase4-gates": "pnpm run check-compatibility && pnpm run check-planning-consistency && pnpm run check-release-channel",
-    "phase5-gates": "pnpm run phase4-gates && pnpm run test"
+    "phase5-gates": "pnpm run phase4-gates && pnpm run test",
+    "pre-release-transcript-hook": "pnpm run build && node scripts/pre-release-transcript-hook.mjs",
+    "transcript:sync": "node scripts/run-transcript-cli.mjs sync-transcripts",
+    "transcript:ingest": "node scripts/run-transcript-cli.mjs ingest-transcripts"
   },
   "devDependencies": {
     "@types/node": "^25.5.0",

package/dist/modules/task-engine/generator.d.ts

@@ -1,3 +0,0 @@
-import type { TaskEntity } from "./types.js";
-export declare function generateTasksMd(tasks: TaskEntity[]): string;
-export declare function syncTaskHeadingsInMarkdown(markdown: string, tasks: TaskEntity[]): string;