@workflow-cannon/workspace-kit 0.7.0 → 0.9.0

package/dist/modules/improvement/improvement-state.js

@@ -1,6 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-export const IMPROVEMENT_STATE_SCHEMA_VERSION = 1;
+export const IMPROVEMENT_STATE_SCHEMA_VERSION = 2;
 const DEFAULT_REL = ".workspace-kit/improvement/state.json";
 function statePath(workspacePath) {
     return path.join(workspacePath, DEFAULT_REL);
@@ -13,21 +13,46 @@ export function emptyImprovementState() {
         transitionLogLengthCursor: 0,
         transcriptLineCursors: {},
         lastSyncRunAt: null,
-        lastIngestRunAt: null
+        lastIngestRunAt: null,
+        transcriptRetryQueue: []
+    };
+}
+function migrateFromV1(raw) {
+    const base = emptyImprovementState();
+    return {
+        ...base,
+        policyTraceLineCursor: typeof raw.policyTraceLineCursor === "number" ? raw.policyTraceLineCursor : 0,
+        mutationLineCursor: typeof raw.mutationLineCursor === "number" ? raw.mutationLineCursor : 0,
+        transitionLogLengthCursor: typeof raw.transitionLogLengthCursor === "number" ? raw.transitionLogLengthCursor : 0,
+        transcriptLineCursors: raw.transcriptLineCursors && typeof raw.transcriptLineCursors === "object" && raw.transcriptLineCursors !== null
+            ? raw.transcriptLineCursors
+            : {},
+        lastSyncRunAt: typeof raw.lastSyncRunAt === "string" ? raw.lastSyncRunAt : null,
+        lastIngestRunAt: typeof raw.lastIngestRunAt === "string" ? raw.lastIngestRunAt : null
     };
 }
 export async function loadImprovementState(workspacePath) {
     const fp = statePath(workspacePath);
     try {
-        const raw = await fs.readFile(fp, "utf8");
-        const doc = JSON.parse(raw);
-        if (doc.schemaVersion !== IMPROVEMENT_STATE_SCHEMA_VERSION) {
+        const rawText = await fs.readFile(fp, "utf8");
+        const raw = JSON.parse(rawText);
+        const ver = raw.schemaVersion;
+        if (ver === 1) {
+            return migrateFromV1(raw);
+        }
+        if (ver !== IMPROVEMENT_STATE_SCHEMA_VERSION) {
             return emptyImprovementState();
         }
+        const doc = raw;
         return {
             ...emptyImprovementState(),
             ...doc,
-            transcriptLineCursors: doc.transcriptLineCursors ?? {}
+            transcriptLineCursors: doc.transcriptLineCursors ?? {},
+            transcriptRetryQueue: Array.isArray(doc.transcriptRetryQueue)
+                ? doc.transcriptRetryQueue.filter((e) => e !== null &&
+                    typeof e === "object" &&
+                    typeof e.relativePath === "string")
+                : []
         };
     }
     catch (e) {
@@ -40,5 +65,9 @@ export async function loadImprovementState(workspacePath) {
 export async function saveImprovementState(workspacePath, doc) {
     const fp = statePath(workspacePath);
     await fs.mkdir(path.dirname(fp), { recursive: true });
-    await fs.writeFile(fp, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    const out = {
+        ...doc,
+        schemaVersion: IMPROVEMENT_STATE_SCHEMA_VERSION
+    };
+    await fs.writeFile(fp, `${JSON.stringify(out, null, 2)}\n`, "utf8");
 }

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."
                 }
             ]
         }
@@ -52,13 +58,25 @@ export const improvementModule = {
             const transcriptsRoot = typeof args.transcriptsRoot === "string" ? args.transcriptsRoot : undefined;
             const fromTag = typeof args.fromTag === "string" ? args.fromTag : undefined;
             const toTag = typeof args.toTag === "string" ? args.toTag : undefined;
+            const syncArgs = {
+                sourcePath: typeof args.sourcePath === "string" ? args.sourcePath : undefined,
+                archivePath: transcriptsRoot
+            };
             try {
-                const result = await runGenerateRecommendations(ctx, { transcriptsRoot, fromTag, toTag });
+                const state = await loadImprovementState(ctx.workspacePath);
+                const sync = await runSyncTranscripts(ctx, syncArgs, state);
+                state.lastSyncRunAt = new Date().toISOString();
+                await saveImprovementState(ctx.workspacePath, state);
+                const result = await runGenerateRecommendations(ctx, {
+                    transcriptsRoot: sync.archivePath,
+                    fromTag,
+                    toTag
+                });
                 return {
                     ok: true,
                     code: "recommendations-generated",
-                    message: `Created ${result.created.length} improvement task(s); skipped ${result.skipped} duplicate(s)`,
-                    data: result
+                    message: `After sync (${sync.copied} copied): created ${result.created.length} improvement task(s); skipped ${result.skipped} duplicate(s)`,
+                    data: { sync, ...result }
                 };
             }
             catch (e) {
@@ -72,8 +90,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 +113,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 +135,8 @@ export const improvementModule = {
                     data: {
                         sync,
                         cadence: {
-                            minIntervalMinutes,
-                            skipIfNoNewTranscripts,
+                            minIntervalMinutes: cfg.minIntervalMinutes,
+                            skipIfNoNewTranscripts: cfg.skipIfNoNewTranscripts,
                             decision: cadenceDecision.reason
                         },
                         generatedRecommendations: recommendations
@@ -141,6 +148,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,65 @@
 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;
+/**
+ * Cursor stores agent transcripts under `~/.cursor/projects/<slug>/agent-transcripts`, where `slug`
+ * is the workspace root with path separators replaced by hyphens (drive letter included on Windows).
+ */
+export declare function buildCursorProjectsAgentTranscriptsPath(workspacePath: string): string;
+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,11 @@
 import fs from "node:fs/promises";
+import os from "node:os";
 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 +23,79 @@ 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;
+    }
+}
+/**
+ * Cursor stores agent transcripts under `~/.cursor/projects/<slug>/agent-transcripts`, where `slug`
+ * is the workspace root with path separators replaced by hyphens (drive letter included on Windows).
+ */
+export function buildCursorProjectsAgentTranscriptsPath(workspacePath) {
+    const home = os.homedir();
+    const resolved = path.resolve(workspacePath);
+    const slug = resolved.split(path.sep).filter((s) => s.length > 0).join("-");
+    return path.join(home, ".cursor", "projects", slug, "agent-transcripts");
+}
+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 cursorGlobal = buildCursorProjectsAgentTranscriptsPath(workspacePath);
+    const cursorLabel = path.join("~", ".cursor", "projects", path.basename(path.dirname(cursorGlobal)), "agent-transcripts");
+    tried.push(cursorLabel);
+    if (await pathExists(cursorGlobal)) {
+        return { root: cursorGlobal, discoveredFrom: "cursor-global-project-agent-transcripts", 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 +113,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 +166,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 +286,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 +301,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;