@workflow-cannon/workspace-kit 0.6.0 → 0.8.0

package/dist/modules/improvement/index.js

@@ -1,9 +1,12 @@
 import { queryLineageChain } from "../../core/lineage-store.js";
-import { runGenerateRecommendations } from "./generate-recommendations-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.5.0",
+        version: "0.8.0",
         contractVersion: "1",
         capabilities: ["improvement"],
         dependsOn: ["task-engine", "planning"],
@@ -30,6 +33,21 @@ export const improvementModule = {
                     name: "query-lineage",
                     file: "query-lineage.md",
                     description: "Reconstruct lineage chain for a recommendation task id."
+                },
+                {
+                    name: "sync-transcripts",
+                    file: "sync-transcripts.md",
+                    description: "Sync local transcript JSONL files into the archive."
+                },
+                {
+                    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."
                 }
             ]
         }
@@ -54,6 +72,110 @@ export const improvementModule = {
                 return { ok: false, code: "generate-failed", message: msg };
             }
         }
+        if (command.name === "sync-transcripts") {
+            const syncArgs = {
+                sourcePath: typeof args.sourcePath === "string" ? args.sourcePath : undefined,
+                archivePath: typeof args.archivePath === "string" ? args.archivePath : undefined
+            };
+            try {
+                const state = await loadImprovementState(ctx.workspacePath);
+                const sync = await runSyncTranscripts(ctx, syncArgs, state);
+                state.lastSyncRunAt = new Date().toISOString();
+                await saveImprovementState(ctx.workspacePath, state);
+                return {
+                    ok: true,
+                    code: "transcripts-synced",
+                    message: `Copied ${sync.copied} transcript file(s); skipped ${sync.skippedExisting} existing`,
+                    data: sync
+                };
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return { ok: false, code: "sync-failed", message: msg };
+            }
+        }
+        if (command.name === "ingest-transcripts") {
+            const syncArgs = {
+                sourcePath: typeof args.sourcePath === "string" ? args.sourcePath : undefined,
+                archivePath: typeof args.archivePath === "string" ? args.archivePath : undefined
+            };
+            const now = new Date();
+            try {
+                const state = await loadImprovementState(ctx.workspacePath);
+                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;
+                if (generate) {
+                    recommendations = await runGenerateRecommendations(ctx, {
+                        transcriptsRoot: sync.archivePath
+                    });
+                    state.lastIngestRunAt = now.toISOString();
+                }
+                await saveImprovementState(ctx.workspacePath, state);
+                const status = generate ? "generated" : "skipped";
+                return {
+                    ok: true,
+                    code: "transcripts-ingested",
+                    message: `Ingest ${status}; sync copied ${sync.copied} file(s)`,
+                    data: {
+                        sync,
+                        cadence: {
+                            minIntervalMinutes: cfg.minIntervalMinutes,
+                            skipIfNoNewTranscripts: cfg.skipIfNoNewTranscripts,
+                            decision: cadenceDecision.reason
+                        },
+                        generatedRecommendations: recommendations
+                    }
+                };
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                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

@@ -0,0 +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;
+    };
+};
+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

@@ -0,0 +1,320 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+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
+        : {};
+    const transcripts = improvement.transcripts && typeof improvement.transcripts === "object"
+        ? improvement.transcripts
+        : {};
+    const cadence = improvement.cadence && typeof improvement.cadence === "object"
+        ? improvement.cadence
+        : {};
+    const sourcePathArg = typeof args.sourcePath === "string" ? args.sourcePath.trim() : "";
+    const archivePathArg = typeof args.archivePath === "string" ? args.archivePath.trim() : "";
+    const sourcePathCfg = typeof transcripts.sourcePath === "string" ? transcripts.sourcePath.trim() : "";
+    const archivePathCfg = typeof transcripts.archivePath === "string" ? transcripts.archivePath.trim() : "";
+    const minIntervalCfg = typeof cadence.minIntervalMinutes === "number" && Number.isFinite(cadence.minIntervalMinutes)
+        ? 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 || "",
+        archivePath: archivePathArg || archivePathCfg || "agent-transcripts",
+        minIntervalMinutes: Math.max(1, Math.floor(minIntervalCfg)),
+        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) {
+        const ents = await fs.readdir(cur, { withFileTypes: true });
+        for (const ent of ents) {
+            const abs = path.join(cur, ent.name);
+            if (ent.isDirectory()) {
+                await walk(abs);
+            }
+            else if (ent.isFile() && ent.name.endsWith(".jsonl")) {
+                out.push(path.relative(root, abs));
+            }
+        }
+    }
+    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");
+}
+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 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: [],
+        skipReasons: {},
+        budget: {
+            maxFilesPerSync: cfg.maxFilesPerSync,
+            maxBytesPerFile: cfg.maxBytesPerFile,
+            maxTotalScanBytes: cfg.maxTotalScanBytes,
+            scanBytesUsed: 0
+        },
+        retryQueue: { pending: 0, processedRetries: 0, droppedPermanentFailures: 0 }
+    };
+    let files = [];
+    try {
+        files = await listJsonlRelativePaths(sourceRoot);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        result.errors.push({
+            file: result.sourcePath,
+            code: "source-read-error",
+            message: `${msg} (discovery tried: ${discoveryCandidatesTried.join(", ")})`
+        });
+        return result;
+    }
+    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;
+            try {
+                dstHash = await fileSha256(dst);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    throw error;
+                }
+            }
+            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);
+            result.copied += 1;
+            result.copiedFiles.push(rel);
+        }
+        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;
+}
+export function resolveCadenceDecision(now, previousRunAtIso, minIntervalMinutes, copiedCount, skipIfNoNewTranscripts) {
+    if (copiedCount === 0 && skipIfNoNewTranscripts) {
+        return { shouldRunGenerate: false, reason: "skipped-no-new-transcripts" };
+    }
+    if (!previousRunAtIso) {
+        return { shouldRunGenerate: true, reason: "run-first-ingest" };
+    }
+    const prev = new Date(previousRunAtIso);
+    if (!Number.isFinite(prev.getTime())) {
+        return { shouldRunGenerate: true, reason: "run-invalid-last-ingest-at" };
+    }
+    const elapsedMs = now.getTime() - prev.getTime();
+    const requiredMs = minIntervalMinutes * 60 * 1000;
+    if (elapsedMs < requiredMs) {
+        return { shouldRunGenerate: false, reason: "skipped-min-interval" };
+    }
+    return { shouldRunGenerate: true, reason: "run-min-interval-satisfied" };
+}

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, 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, 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 } from "./generator.js";
-export { importTasksFromMarkdown } from "./importer.js";
 export { getNextActions } from "./suggestions.js";
 export declare const taskEngineModule: WorkflowModule;