cclaw-cli 0.5.3 → 0.5.5

package/dist/trace-matrix.js

@@ -2,22 +2,13 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { RUNTIME_ROOT } from "./constants.js";
 import { exists } from "./fs-utils.js";
-import { readFlowState } from "./runs.js";
 function activeArtifactPath(projectRoot, name) {
     return path.join(projectRoot, RUNTIME_ROOT, "artifacts", name);
 }
-function canonicalRunArtifactPath(projectRoot, runId, name) {
-    return path.join(projectRoot, RUNTIME_ROOT, "runs", runId, "artifacts", name);
-}
-async function readArtifact(projectRoot, name, activeRunId) {
-    const runId = activeRunId.trim();
-    const candidates = runId.length > 0
-        ? [canonicalRunArtifactPath(projectRoot, runId, name), activeArtifactPath(projectRoot, name)]
-        : [activeArtifactPath(projectRoot, name)];
-    for (const candidate of candidates) {
-        if (await exists(candidate)) {
-            return fs.readFile(candidate, "utf8");
-        }
+async function readArtifact(projectRoot, name) {
+    const candidate = activeArtifactPath(projectRoot, name);
+    if (await exists(candidate)) {
+        return fs.readFile(candidate, "utf8");
     }
     return null;
 }
@@ -120,11 +111,10 @@ function layer1LinesForCriterion(layer1, criterionId) {
     return out;
 }
 export async function buildTraceMatrix(projectRoot) {
-    const { activeRunId } = await readFlowState(projectRoot);
-    const spec = await readArtifact(projectRoot, "04-spec.md", activeRunId);
-    const plan = await readArtifact(projectRoot, "05-plan.md", activeRunId);
-    const tdd = await readArtifact(projectRoot, "06-tdd.md", activeRunId);
-    const review = await readArtifact(projectRoot, "07-review.md", activeRunId);
+    const spec = await readArtifact(projectRoot, "04-spec.md");
+    const plan = await readArtifact(projectRoot, "05-plan.md");
+    const tdd = await readArtifact(projectRoot, "06-tdd.md");
+    const review = await readArtifact(projectRoot, "07-review.md");
     const criterionIds = spec ? parseAcceptanceCriterionIds(spec) : [];
     const taskToAcs = plan ? parsePlanTaskAcLinks(plan) : new Map();
     const allTaskIds = plan ? parsePlanTaskIds(plan) : [];

package/dist/types.d.ts

@@ -8,10 +8,6 @@ export interface VibyConfig {
     harnesses: HarnessId[];
     /** When true, stage skills instruct the agent to continue to the following stage after gates pass. */
     autoAdvance?: boolean;
-    /** Merge project bootstrap learnings with a global learnings file. */
-    globalLearnings?: boolean;
-    /** Optional absolute or project-relative path to global learnings JSONL. */
-    globalLearningsPath?: string;
     /** Prompt guard behavior for runtime write-risk detection hooks. */
     promptGuardMode?: "advisory" | "strict";
     /** When true, cclaw installs managed git pre-commit/pre-push wrappers. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {

package/dist/learnings-summarizer.d.ts

@@ -1,25 +0,0 @@
-export interface ObservationRecord {
-    ts?: string;
-    event?: string;
-    tool?: string;
-    phase?: string;
-    stage?: string;
-    runId?: string;
-    data?: unknown;
-}
-export type LearningSource = "observed" | "user-stated" | "inferred";
-export type LearningType = "pitfall" | "pattern" | "preference";
-export interface LearningRecord {
-    ts: string;
-    skill: string;
-    type: LearningType;
-    key: string;
-    insight: string;
-    confidence: number;
-    source: LearningSource;
-}
-export interface SummarizeOutcome {
-    candidates: LearningRecord[];
-    appendable: LearningRecord[];
-}
-export declare function summarizeObservationLearnings(observationJsonl: string, existingLearningsJsonl: string, timestamp: string): SummarizeOutcome;

package/dist/learnings-summarizer.js

@@ -1,201 +0,0 @@
-const ERROR_PATTERN = /(error|fail|timeout|exception)/iu;
-const KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/u;
-function parseJsonLine(line) {
-    const trimmed = line.trim();
-    if (!trimmed)
-        return null;
-    try {
-        const parsed = JSON.parse(trimmed);
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-            return null;
-        return parsed;
-    }
-    catch {
-        return null;
-    }
-}
-function toText(value) {
-    if (typeof value === "string")
-        return value;
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return "";
-    }
-}
-function asValidLearning(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return null;
-    const obj = value;
-    const ts = obj.ts;
-    const skill = obj.skill;
-    const type = obj.type;
-    const key = obj.key;
-    const insight = obj.insight;
-    const confidence = obj.confidence;
-    const source = obj.source;
-    if (typeof ts !== "string" || !ts)
-        return null;
-    if (typeof skill !== "string" || !skill)
-        return null;
-    if (type !== "pitfall" && type !== "pattern" && type !== "preference")
-        return null;
-    if (typeof key !== "string" || !KEY_PATTERN.test(key))
-        return null;
-    if (typeof insight !== "string" || insight.trim().length < 16)
-        return null;
-    if (typeof confidence !== "number" || !Number.isInteger(confidence) || confidence < 1 || confidence > 10)
-        return null;
-    if (source !== "observed" && source !== "user-stated" && source !== "inferred")
-        return null;
-    return {
-        ts,
-        skill,
-        type,
-        key,
-        insight,
-        confidence,
-        source
-    };
-}
-function normalizeToken(value) {
-    const normalized = value.trim().replace(/[^A-Za-z0-9._-]+/gu, "-");
-    return normalized.replace(/^-+/u, "").replace(/-+$/u, "") || "unknown";
-}
-function maybeObservation(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return null;
-    const obj = value;
-    return {
-        ts: typeof obj.ts === "string" ? obj.ts : undefined,
-        event: typeof obj.event === "string" ? obj.event : undefined,
-        tool: typeof obj.tool === "string" ? obj.tool : undefined,
-        phase: typeof obj.phase === "string" ? obj.phase : undefined,
-        stage: typeof obj.stage === "string" ? obj.stage : undefined,
-        runId: typeof obj.runId === "string" ? obj.runId : undefined,
-        data: obj.data
-    };
-}
-function bestByConfidence(candidates) {
-    const table = new Map();
-    for (const candidate of candidates) {
-        const token = `${candidate.key}:${candidate.type}`;
-        const current = table.get(token);
-        if (!current || candidate.confidence > current.confidence) {
-            table.set(token, candidate);
-        }
-    }
-    return Array.from(table.values());
-}
-function buildCandidates(observations, timestamp) {
-    const toolUsage = new Map();
-    const toolErrors = new Map();
-    const stageErrors = new Map();
-    const longPayload = new Map();
-    for (const obs of observations) {
-        const tool = normalizeToken(obs.tool ?? "unknown");
-        const stage = normalizeToken(obs.stage ?? "none");
-        const payload = toText(obs.data);
-        toolUsage.set(tool, (toolUsage.get(tool) ?? 0) + 1);
-        if (payload.length >= 1500) {
-            longPayload.set(tool, (longPayload.get(tool) ?? 0) + 1);
-        }
-        if ((obs.event ?? "") === "tool_complete" && ERROR_PATTERN.test(payload)) {
-            toolErrors.set(tool, (toolErrors.get(tool) ?? 0) + 1);
-            stageErrors.set(stage, (stageErrors.get(stage) ?? 0) + 1);
-        }
-    }
-    const candidates = [];
-    for (const [tool, errors] of toolErrors.entries()) {
-        if (errors < 3)
-            continue;
-        candidates.push({
-            ts: timestamp,
-            skill: "observation",
-            type: "pitfall",
-            key: `frequent-errors-${tool}`,
-            insight: `Tool ${tool} produced ${errors} error-like completions in a single session; add a preflight checklist before using it.`,
-            confidence: Math.min(9, 4 + Math.floor(errors / 2)),
-            source: "observed"
-        });
-    }
-    for (const [tool, total] of toolUsage.entries()) {
-        if (total < 8)
-            continue;
-        const errors = toolErrors.get(tool) ?? 0;
-        if (errors > Math.max(1, Math.floor(total * 0.15)))
-            continue;
-        candidates.push({
-            ts: timestamp,
-            skill: "observation",
-            type: "pattern",
-            key: `reliable-tool-${tool}`,
-            insight: `Tool ${tool} was used ${total} times with low failure rate; prefer it as a first option for similar tasks.`,
-            confidence: Math.min(8, 3 + Math.floor(total / 3)),
-            source: "observed"
-        });
-    }
-    for (const [stage, errors] of stageErrors.entries()) {
-        if (stage === "none" || errors < 4)
-            continue;
-        candidates.push({
-            ts: timestamp,
-            skill: "observation",
-            type: "pitfall",
-            key: `stage-hotspot-${stage}`,
-            insight: `Stage ${stage} produced ${errors} error-like tool completions in one session; add stage-specific checks before execution.`,
-            confidence: Math.min(8, 3 + Math.floor(errors / 2)),
-            source: "observed"
-        });
-    }
-    for (const [tool, count] of longPayload.entries()) {
-        if (count < 3)
-            continue;
-        candidates.push({
-            ts: timestamp,
-            skill: "observation",
-            type: "preference",
-            key: `truncate-heavy-payloads-${tool}`,
-            insight: `Tool ${tool} produced large payloads repeatedly; summarize outputs earlier to avoid context pressure.`,
-            confidence: Math.min(7, 3 + Math.floor(count / 2)),
-            source: "observed"
-        });
-    }
-    return bestByConfidence(candidates).filter((entry) => asValidLearning(entry) !== null);
-}
-function appendableCandidates(existing, candidates) {
-    const bestExisting = new Map();
-    for (const entry of existing) {
-        const token = `${entry.key}:${entry.type}`;
-        const current = bestExisting.get(token) ?? 0;
-        if (entry.confidence > current)
-            bestExisting.set(token, entry.confidence);
-    }
-    const appendable = [];
-    for (const candidate of candidates) {
-        const token = `${candidate.key}:${candidate.type}`;
-        const current = bestExisting.get(token) ?? 0;
-        if (candidate.confidence > current) {
-            appendable.push(candidate);
-            bestExisting.set(token, candidate.confidence);
-        }
-    }
-    return appendable;
-}
-export function summarizeObservationLearnings(observationJsonl, existingLearningsJsonl, timestamp) {
-    const observations = observationJsonl
-        .split(/\r?\n/gu)
-        .map(parseJsonLine)
-        .filter((value) => value !== null)
-        .map(maybeObservation)
-        .filter((value) => value !== null);
-    const existing = existingLearningsJsonl
-        .split(/\r?\n/gu)
-        .map(parseJsonLine)
-        .map((value) => (value ? asValidLearning(value) : null))
-        .filter((value) => value !== null);
-    const candidates = buildCandidates(observations, timestamp);
-    const appendable = appendableCandidates(existing, candidates);
-    return { candidates, appendable };
-}