@workflow-cannon/workspace-kit 0.4.0 → 0.5.0

package/dist/modules/improvement/ingest.js

@@ -0,0 +1,223 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import crypto from "node:crypto";
+import { computeHeuristicConfidence, shouldAdmitRecommendation } from "./confidence.js";
+function sha256Hex(s) {
+    return crypto.createHash("sha256").update(s, "utf8").digest("hex");
+}
+function stableEvidenceKey(kind, parts) {
+    return `${kind}:${sha256Hex(parts.join("\0")).slice(0, 40)}`;
+}
+async function readJsonlLines(filePath) {
+    try {
+        const raw = await fs.readFile(filePath, "utf8");
+        return raw.split("\n").filter((l) => l.trim().length > 0);
+    }
+    catch (e) {
+        if (e.code === "ENOENT")
+            return [];
+        throw e;
+    }
+}
+async function globJsonlRecursive(dir, acc = []) {
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch (e) {
+        if (e.code === "ENOENT")
+            return acc;
+        throw e;
+    }
+    for (const ent of entries) {
+        const p = path.join(dir, ent.name);
+        if (ent.isDirectory()) {
+            await globJsonlRecursive(p, acc);
+        }
+        else if (ent.isFile() && ent.name.endsWith(".jsonl")) {
+            acc.push(p);
+        }
+    }
+    return acc;
+}
+const FRICTION = /\b(error|fail|broken|hosed|bug|crash|denied|invalid|exception)\b/i;
+function scoreTranscriptLine(line) {
+    if (!FRICTION.test(line))
+        return 0;
+    let s = 0.45;
+    if (/\b(always|again|still|never)\b/i.test(line))
+        s += 0.15;
+    return Math.min(1, s);
+}
+export async function ingestAgentTranscripts(workspacePath, transcriptsRootRel, state) {
+    const root = path.resolve(workspacePath, transcriptsRootRel);
+    const files = await globJsonlRecursive(root);
+    const out = [];
+    for (const abs of files.sort()) {
+        const rel = path.relative(workspacePath, abs);
+        const lines = await readJsonlLines(abs);
+        const start = state.transcriptLineCursors[rel] ?? 0;
+        const slice = lines.slice(start);
+        let maxScore = 0;
+        let sampleLine = "";
+        for (const line of slice) {
+            const sc = scoreTranscriptLine(line);
+            if (sc > maxScore) {
+                maxScore = sc;
+                sampleLine = line.slice(0, 200);
+            }
+        }
+        state.transcriptLineCursors[rel] = lines.length;
+        if (maxScore === 0)
+            continue;
+        const evidenceKey = stableEvidenceKey("transcript", [rel, String(start), String(lines.length)]);
+        const signals = { transcriptFriction: maxScore };
+        const confidence = computeHeuristicConfidence("transcript", signals);
+        if (!shouldAdmitRecommendation(confidence))
+            continue;
+        out.push({
+            evidenceKind: "transcript",
+            evidenceKey,
+            title: `Reduce friction hinted in transcript (${path.basename(rel)})`,
+            provenanceRefs: { transcriptPath: rel, sampleLine },
+            signals,
+            confidence
+        });
+    }
+    return out;
+}
+export function ingestGitDiffBetweenTags(workspacePath, fromTag, toTag) {
+    let names;
+    try {
+        names = execFileSync("git", ["-C", workspacePath, "diff", `${fromTag}..${toTag}`, "--name-only"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    }
+    catch {
+        return null;
+    }
+    const fileList = names.split("\n").filter(Boolean);
+    const churn = Math.min(1, fileList.length / 25);
+    const impact = 0.4 + churn * 0.55;
+    const evidenceKey = stableEvidenceKey("git_diff", [fromTag, toTag, fileList.slice(0, 30).join(",")]);
+    const signals = { diffImpact: impact };
+    const confidence = computeHeuristicConfidence("git_diff", signals);
+    if (!shouldAdmitRecommendation(confidence))
+        return null;
+    return {
+        evidenceKind: "git_diff",
+        evidenceKey,
+        title: `Review workflow impact of changes ${fromTag} → ${toTag} (${fileList.length} paths)`,
+        provenanceRefs: { fromTag, toTag, pathCount: String(fileList.length) },
+        signals,
+        confidence
+    };
+}
+export async function ingestPolicyDenials(workspacePath, state) {
+    const fp = path.join(workspacePath, ".workspace-kit/policy/traces.jsonl");
+    const lines = await readJsonlLines(fp);
+    const start = state.policyTraceLineCursor;
+    const slice = lines.slice(start);
+    state.policyTraceLineCursor = lines.length;
+    const out = [];
+    for (const line of slice) {
+        let rec;
+        try {
+            rec = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (rec.allowed !== false)
+            continue;
+        const op = typeof rec.operationId === "string" ? rec.operationId : "unknown";
+        const ts = typeof rec.timestamp === "string" ? rec.timestamp : "";
+        const evidenceKey = stableEvidenceKey("policy_deny", [op, ts, line.slice(0, 120)]);
+        const hasRationale = typeof rec.rationale === "string" && rec.rationale.length > 0;
+        const policyDenial = hasRationale ? 0.72 : 0.55;
+        const signals = { policyDenial };
+        const confidence = computeHeuristicConfidence("policy_deny", signals);
+        if (!shouldAdmitRecommendation(confidence))
+            continue;
+        out.push({
+            evidenceKind: "policy_deny",
+            evidenceKey,
+            title: `Soften or document policy friction for ${op}`,
+            provenanceRefs: {
+                operationId: op,
+                traceTimestamp: ts,
+                command: typeof rec.command === "string" ? rec.command : ""
+            },
+            signals,
+            confidence
+        });
+    }
+    return out;
+}
+export async function ingestConfigMutations(workspacePath, state) {
+    const fp = path.join(workspacePath, ".workspace-kit/config/mutations.jsonl");
+    const lines = await readJsonlLines(fp);
+    const start = state.mutationLineCursor;
+    const slice = lines.slice(start);
+    state.mutationLineCursor = lines.length;
+    const out = [];
+    for (const line of slice) {
+        let rec;
+        try {
+            rec = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (rec.ok === true)
+            continue;
+        const ts = typeof rec.timestamp === "string" ? rec.timestamp : "";
+        const k = typeof rec.key === "string" ? rec.key : "";
+        const evidenceKey = stableEvidenceKey("config_mutation", ["mutations.jsonl", ts, k, String(rec.code ?? "")]);
+        const mutationRejection = 0.62;
+        const signals = { mutationRejection };
+        const confidence = computeHeuristicConfidence("config_mutation", signals);
+        if (!shouldAdmitRecommendation(confidence))
+            continue;
+        out.push({
+            evidenceKind: "config_mutation",
+            evidenceKey,
+            title: `Improve config UX or validation for key ${k || "(unknown)"}`,
+            provenanceRefs: { mutationsFile: "mutations.jsonl", timestamp: ts, key: k },
+            signals,
+            confidence
+        });
+    }
+    return out;
+}
+export function ingestTaskTransitionFriction(transitionLog, state) {
+    const start = state.transitionLogLengthCursor;
+    const slice = transitionLog.slice(start);
+    state.transitionLogLengthCursor = transitionLog.length;
+    const counts = new Map();
+    for (const ev of slice) {
+        counts.set(ev.taskId, (counts.get(ev.taskId) ?? 0) + 1);
+    }
+    const out = [];
+    for (const [taskId, count] of counts) {
+        if (count < 4)
+            continue;
+        const taskFriction = Math.min(1, 0.38 + count * 0.08);
+        const evidenceKey = stableEvidenceKey("task_transition", [taskId, String(count)]);
+        const signals = { taskFriction };
+        const confidence = computeHeuristicConfidence("task_transition", signals);
+        if (!shouldAdmitRecommendation(confidence))
+            continue;
+        out.push({
+            evidenceKind: "task_transition",
+            evidenceKey,
+            title: `Stabilize transitions for task ${taskId} (high churn: ${count} events)`,
+            provenanceRefs: { taskId, transitionEventCount: String(count) },
+            signals,
+            confidence
+        });
+    }
+    return out;
+}
+export function taskIdForEvidenceKey(evidenceKey) {
+    return `imp-${sha256Hex(evidenceKey).slice(0, 14)}`;
+}

package/dist/modules/index.d.ts

@@ -2,6 +2,7 @@ export { approvalsModule } from "./approvals/index.js";
 export { documentationModule } from "./documentation/index.js";
 export type { DocumentationConflict, DocumentationGenerateOptions, DocumentationGenerateResult, DocumentationGenerationEvidence, DocumentationValidationIssue } from "./documentation/types.js";
 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";

package/dist/modules/index.js

@@ -1,6 +1,7 @@
 export { approvalsModule } from "./approvals/index.js";
 export { documentationModule } from "./documentation/index.js";
 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";

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

@@ -23,7 +23,7 @@ function taskStorePath(ctx) {
 export const taskEngineModule = {
     registration: {
         id: "task-engine",
-        version: "0.4.0",
+        version: "0.5.0",
         contractVersion: "1",
         capabilities: ["task-engine"],
         dependsOn: [],

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

@@ -13,6 +13,7 @@ const ALLOWED_TRANSITIONS = {
     "ready->blocked": { action: "block" },
     "ready->cancelled": { action: "cancel" },
     "in_progress->completed": { action: "complete" },
+    "in_progress->cancelled": { action: "decline" },
     "in_progress->blocked": { action: "block" },
     "in_progress->ready": { action: "pause" },
     "blocked->ready": { action: "unblock" },

package/dist/modules/workspace-config/index.js

@@ -1,4 +1,4 @@
-import { explainConfigPath, resolveWorkspaceConfigWithLayers } from "../../core/workspace-kit-config.js";
+import { explainConfigPath, normalizeConfigForExport, resolveWorkspaceConfigWithLayers } from "../../core/workspace-kit-config.js";
 async function handleExplainConfig(args, ctx) {
     const pathArg = typeof args.path === "string" ? args.path.trim() : "";
     if (!pathArg) {
@@ -23,6 +23,24 @@ async function handleExplainConfig(args, ctx) {
         data: explained
     };
 }
+async function handleResolveConfig(args, ctx) {
+    const invocationConfig = typeof args.config === "object" && args.config !== null && !Array.isArray(args.config)
+        ? args.config
+        : {};
+    const { effective, layers } = await resolveWorkspaceConfigWithLayers({
+        workspacePath: ctx.workspacePath,
+        registry: ctx.registry,
+        invocationConfig
+    });
+    return {
+        ok: true,
+        code: "config-resolved",
+        data: {
+            effective: normalizeConfigForExport(effective),
+            layers: layers.map((l) => ({ id: l.id }))
+        }
+    };
+}
 export const workspaceConfigModule = {
     registration: {
         id: "workspace-config",
@@ -48,25 +66,35 @@ export const workspaceConfigModule = {
                     name: "explain-config",
                     file: "explain-config.md",
                     description: "Agent-first JSON: effective config value and winning layer for a dotted path."
+                },
+                {
+                    name: "resolve-config",
+                    file: "resolve-config.md",
+                    description: "Agent-first JSON: full effective config (sorted) and merge layer ids."
                 }
             ]
         }
     },
     async onCommand(command, ctx) {
-        if (command.name !== "explain-config") {
-            return { ok: false, code: "unknown-command", message: "workspace-config only implements explain-config" };
-        }
         const reg = ctx.moduleRegistry;
         if (!reg) {
             return {
                 ok: false,
                 code: "internal-error",
-                message: "explain-config requires moduleRegistry on context (CLI wiring)"
+                message: "workspace-config requires moduleRegistry on context (CLI wiring)"
             };
         }
-        return handleExplainConfig(command.args ?? {}, {
-            workspacePath: ctx.workspacePath,
-            registry: reg
-        });
+        const baseCtx = { workspacePath: ctx.workspacePath, registry: reg };
+        if (command.name === "explain-config") {
+            return handleExplainConfig(command.args ?? {}, baseCtx);
+        }
+        if (command.name === "resolve-config") {
+            return handleResolveConfig(command.args ?? {}, baseCtx);
+        }
+        return {
+            ok: false,
+            code: "unknown-command",
+            message: `workspace-config: unknown command '${command.name}'`
+        };
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow-cannon/workspace-kit",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "private": false,
   "packageManager": "pnpm@10.0.0",
   "license": "MIT",