cclaw-cli 0.5.4 → 0.5.5

package/dist/doctor.js

@@ -426,10 +426,7 @@ export async function doctorChecks(projectRoot, options = {}) {
         "stop-checkpoint.sh",
         "prompt-guard.sh",
         "workflow-guard.sh",
-        "context-monitor.sh",
-        "observe.sh",
-        "summarize-observations.sh",
-        "summarize-observations.mjs"
+        "context-monitor.sh"
     ]) {
         const scriptPath = path.join(projectRoot, RUNTIME_ROOT, "hooks", script);
         const scriptExists = await exists(scriptPath);
@@ -524,15 +521,12 @@ export async function doctorChecks(projectRoot, options = {}) {
         const wiringOk = sessionCommands.some((cmd) => cmd.includes("session-start.sh")) &&
             preCommands.some((cmd) => cmd.includes("prompt-guard.sh")) &&
             preCommands.some((cmd) => cmd.includes("workflow-guard.sh")) &&
-            preCommands.some((cmd) => cmd.includes("observe.sh pre")) &&
-            postCommands.some((cmd) => cmd.includes("observe.sh post")) &&
             postCommands.some((cmd) => cmd.includes("context-monitor.sh")) &&
-            stopCommands.some((cmd) => cmd.includes("summarize-observations.sh")) &&
             stopCommands.some((cmd) => cmd.includes("stop-checkpoint.sh"));
         checks.push({
             name: "hook:wiring:claude",
             ok: wiringOk,
-            details: `${file} must wire session-start/prompt-guard/workflow-guard/observe/context-monitor/summarize/stop-checkpoint`
+            details: `${file} must wire session-start/prompt-guard/workflow-guard/context-monitor/stop-checkpoint`
         });
     }
     if (configuredHarnesses.includes("cursor")) {
@@ -560,15 +554,12 @@ export async function doctorChecks(projectRoot, options = {}) {
         const wiringOk = sessionCommands.some((cmd) => cmd.includes("session-start.sh")) &&
             preCommands.some((cmd) => cmd.includes("prompt-guard.sh")) &&
             preCommands.some((cmd) => cmd.includes("workflow-guard.sh")) &&
-            preCommands.some((cmd) => cmd.includes("observe.sh pre")) &&
-            postCommands.some((cmd) => cmd.includes("observe.sh post")) &&
             postCommands.some((cmd) => cmd.includes("context-monitor.sh")) &&
-            stopCommands.some((cmd) => cmd.includes("summarize-observations.sh")) &&
             stopCommands.some((cmd) => cmd.includes("stop-checkpoint.sh"));
         checks.push({
             name: "hook:wiring:cursor",
             ok: wiringOk,
-            details: `${file} must wire session-start/prompt-guard/workflow-guard/observe/context-monitor/summarize/stop-checkpoint`
+            details: `${file} must wire session-start/prompt-guard/workflow-guard/context-monitor/stop-checkpoint`
         });
         const cursorRulePath = path.join(projectRoot, ".cursor/rules/cclaw-workflow.mdc");
         let cursorRuleOk = false;
@@ -603,15 +594,12 @@ export async function doctorChecks(projectRoot, options = {}) {
         const wiringOk = sessionCommands.some((cmd) => cmd.includes("session-start.sh")) &&
             preCommands.some((cmd) => cmd.includes("prompt-guard.sh")) &&
             preCommands.some((cmd) => cmd.includes("workflow-guard.sh")) &&
-            preCommands.some((cmd) => cmd.includes("observe.sh pre")) &&
-            postCommands.some((cmd) => cmd.includes("observe.sh post")) &&
             postCommands.some((cmd) => cmd.includes("context-monitor.sh")) &&
-            stopCommands.some((cmd) => cmd.includes("summarize-observations.sh")) &&
             stopCommands.some((cmd) => cmd.includes("stop-checkpoint.sh"));
         checks.push({
             name: "hook:wiring:codex",
             ok: wiringOk,
-            details: `${file} must wire session-start/prompt-guard/workflow-guard/observe/context-monitor/summarize/stop-checkpoint`
+            details: `${file} must wire session-start/prompt-guard/workflow-guard/context-monitor/stop-checkpoint`
         });
     }
     if (configuredHarnesses.includes("opencode")) {
@@ -627,7 +615,6 @@ export async function doctorChecks(projectRoot, options = {}) {
                     content.includes("workflow-guard.sh") &&
                     content.includes("context-monitor.sh") &&
                     content.includes('"session.idle"') &&
-                    content.includes('"session.updated"') &&
                     content.includes('"session.resumed"') &&
                     content.includes('"session.cleared"') &&
                     content.includes('"experimental.chat.system.transform"');
@@ -635,7 +622,7 @@ export async function doctorChecks(projectRoot, options = {}) {
         checks.push({
             name: "lifecycle:opencode:rehydration_events",
             ok,
-            details: `${file} must include event lifecycle handler, tool.execute.before/after with prompt/workflow/context hooks, session.idle summarization, and transform rehydration`
+            details: `${file} must include event lifecycle handler, tool.execute.before/after with prompt/workflow/context hooks, session.idle checkpoint, and transform rehydration`
         });
         const runtimeShape = await opencodePluginRuntimeShapeCheck(projectRoot);
         checks.push({
@@ -679,11 +666,11 @@ export async function doctorChecks(projectRoot, options = {}) {
         ok: true,
         details: hasPython ? "python3 available" : "warning: python3 not found, jq/node paths must stay healthy"
     });
-    // Learnings store exists
+    // Knowledge store exists
     checks.push({
-        name: "learnings:store_exists",
-        ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "learnings.jsonl")),
-        details: `${RUNTIME_ROOT}/learnings.jsonl must exist (can be empty)`
+        name: "knowledge:store_exists",
+        ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "knowledge.md")),
+        details: `${RUNTIME_ROOT}/knowledge.md must exist`
     });
     checks.push({
         name: "state:checkpoint_exists",
@@ -751,38 +738,20 @@ export async function doctorChecks(projectRoot, options = {}) {
         });
     }
     const activeRunId = typeof flowState.activeRunId === "string" ? flowState.activeRunId.trim() : "";
-    const runActivationDeferred = activeRunId === "run-pending";
     checks.push({
         name: "flow_state:active_run_id",
         ok: activeRunId.length > 0,
-        details: `${RUNTIME_ROOT}/state/flow-state.json must include activeRunId (run-pending is allowed before first active run is materialized)`
+        details: `${RUNTIME_ROOT}/state/flow-state.json must include activeRunId`
     });
     checks.push({
-        name: "run:active_artifacts",
-        ok: runActivationDeferred
-            ? true
-            : await exists(path.join(projectRoot, RUNTIME_ROOT, "runs", activeRunId, "artifacts")),
-        details: runActivationDeferred
-            ? "active run artifacts are deferred until first feature run activation"
-            : `${RUNTIME_ROOT}/runs/${activeRunId}/artifacts must exist`
+        name: "artifacts:active_root",
+        ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "artifacts")),
+        details: `${RUNTIME_ROOT}/artifacts must exist as the active artifact root`
     });
     checks.push({
-        name: "run:active_metadata",
-        ok: runActivationDeferred
-            ? true
-            : await exists(path.join(projectRoot, RUNTIME_ROOT, "runs", activeRunId, "run.json")),
-        details: runActivationDeferred
-            ? "active run metadata is deferred until first feature run activation"
-            : `${RUNTIME_ROOT}/runs/${activeRunId}/run.json must exist`
-    });
-    checks.push({
-        name: "run:active_handoff",
-        ok: runActivationDeferred
-            ? true
-            : await exists(path.join(projectRoot, RUNTIME_ROOT, "runs", activeRunId, "handoff.md")),
-        details: runActivationDeferred
-            ? "active run handoff is deferred until first feature run activation"
-            : `${RUNTIME_ROOT}/runs/${activeRunId}/handoff.md must exist`
+        name: "runs:archive_root",
+        ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "runs")),
+        details: `${RUNTIME_ROOT}/runs must exist for archived feature snapshots`
     });
     const delegation = await checkMandatoryDelegations(projectRoot, flowState.currentStage);
     checks.push({

package/dist/flow-state.js

@@ -1,7 +1,7 @@
 import { COMMAND_FILE_ORDER } from "./constants.js";
 import { buildTransitionRules, orderedStageSchemas, stageGateIds } from "./content/stage-schema.js";
 export const TRANSITION_RULES = buildTransitionRules();
-export function createInitialFlowState(activeRunId = "run-pending") {
+export function createInitialFlowState(activeRunId = "active") {
     const stageGateCatalog = {};
     for (const schema of orderedStageSchemas()) {
         stageGateCatalog[schema.stage] = {

package/dist/harness-adapters.js

@@ -37,7 +37,7 @@ Before responding to a coding request:
 |---|---|
 | \`/cc\` | **Entry point.** No args = resume current stage. With prompt = start brainstorm with idea. |
 | \`/cc-next\` | **Progression.** Advances to the next stage when current is complete. |
-| \`/cc-learn\` | **Cross-cutting.** Capture or review project learnings. |
+| \`/cc-learn\` | **Cross-cutting.** Capture or review project knowledge. |
 
 **Stage order:** brainstorm > scope > design > spec > plan > tdd > review > ship.
 \`/cc-next\` loads the right stage skill automatically. Gates must pass before handoff.

package/dist/install.js

@@ -1,6 +1,5 @@
 import { execFile } from "node:child_process";
 import fs from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
 import { COMMAND_FILE_ORDER, REQUIRED_DIRS, RUNTIME_ROOT, UTILITY_COMMANDS } from "./constants.js";
@@ -13,7 +12,7 @@ import { startCommandContract, startCommandSkillMarkdown } from "./content/start
 import { subagentDrivenDevSkill, parallelAgentsSkill } from "./content/subagents.js";
 import { sessionHooksSkillMarkdown } from "./content/session-hooks.js";
 import { sessionStartScript, stopCheckpointScript, opencodePluginJs, claudeHooksJson, cursorHooksJson, codexHooksJson } from "./content/hooks.js";
-import { contextMonitorScript, observeScript, promptGuardScript, workflowGuardScript, summarizeObservationsRuntimeModule, summarizeObservationsScript } from "./content/observe.js";
+import { contextMonitorScript, promptGuardScript, workflowGuardScript } from "./content/observe.js";
 import { META_SKILL_NAME, usingCclawSkillMarkdown } from "./content/meta-skill.js";
 import { ARTIFACT_TEMPLATES, CURSOR_WORKFLOW_RULE_MDC, RULEBOOK_MARKDOWN, buildRulesJson } from "./content/templates.js";
 import { stageSkillFolder, stageSkillMarkdown } from "./content/skills.js";
@@ -32,22 +31,6 @@ const execFileAsync = promisify(execFile);
 function runtimePath(projectRoot, ...segments) {
     return path.join(projectRoot, RUNTIME_ROOT, ...segments);
 }
-function resolveGlobalLearningsPath(projectRoot, config) {
-    if (config.globalLearnings !== true) {
-        return null;
-    }
-    const raw = config.globalLearningsPath?.trim() ?? "";
-    if (raw.length === 0) {
-        return path.join(os.homedir(), ".cclaw-global-learnings.jsonl");
-    }
-    if (raw.startsWith("~/")) {
-        return path.join(os.homedir(), raw.slice(2));
-    }
-    if (path.isAbsolute(raw)) {
-        return raw;
-    }
-    return path.join(projectRoot, raw);
-}
 async function resolveGitHooksDir(projectRoot) {
     try {
         const { stdout } = await execFileAsync("git", ["rev-parse", "--git-path", "hooks"], {
@@ -497,23 +480,14 @@ async function writeHooks(projectRoot, config) {
     const harnesses = config.harnesses;
     const hooksDir = runtimePath(projectRoot, "hooks");
     await ensureDir(hooksDir);
-    await writeFileSafe(path.join(hooksDir, "session-start.sh"), sessionStartScript({
-        globalLearningsEnabled: config.globalLearnings === true,
-        globalLearningsPath: config.globalLearningsPath
-    }));
+    await writeFileSafe(path.join(hooksDir, "session-start.sh"), sessionStartScript());
     await writeFileSafe(path.join(hooksDir, "stop-checkpoint.sh"), stopCheckpointScript());
     await writeFileSafe(path.join(hooksDir, "prompt-guard.sh"), promptGuardScript({
         strictMode: config.promptGuardMode === "strict"
     }));
     await writeFileSafe(path.join(hooksDir, "workflow-guard.sh"), workflowGuardScript());
     await writeFileSafe(path.join(hooksDir, "context-monitor.sh"), contextMonitorScript());
-    await writeFileSafe(path.join(hooksDir, "observe.sh"), observeScript());
-    await writeFileSafe(path.join(hooksDir, "summarize-observations.sh"), summarizeObservationsScript());
-    await writeFileSafe(path.join(hooksDir, "summarize-observations.mjs"), summarizeObservationsRuntimeModule());
-    const opencodePluginSource = opencodePluginJs({
-        globalLearningsEnabled: config.globalLearnings === true,
-        globalLearningsPath: config.globalLearningsPath
-    });
+    const opencodePluginSource = opencodePluginJs();
     await writeFileSafe(path.join(hooksDir, "opencode-plugin.mjs"), opencodePluginSource);
     try {
         for (const script of [
@@ -522,9 +496,6 @@ async function writeHooks(projectRoot, config) {
             "prompt-guard.sh",
             "workflow-guard.sh",
             "context-monitor.sh",
-            "observe.sh",
-            "summarize-observations.sh",
-            "summarize-observations.mjs",
             "opencode-plugin.mjs"
         ]) {
             await fs.chmod(path.join(hooksDir, script), 0o755);
@@ -565,20 +536,10 @@ async function writeHooks(projectRoot, config) {
         // OpenCode registration is auto-managed via opencode.json/opencode.jsonc.
     }
 }
-async function ensureLearningsStore(projectRoot) {
-    const storePath = runtimePath(projectRoot, "learnings.jsonl");
+async function ensureKnowledgeStore(projectRoot) {
+    const storePath = runtimePath(projectRoot, "knowledge.md");
     if (!(await exists(storePath))) {
-        await writeFileSafe(storePath, "");
-    }
-}
-async function ensureGlobalLearningsStore(projectRoot, config) {
-    const globalPath = resolveGlobalLearningsPath(projectRoot, config);
-    if (!globalPath) {
-        return;
-    }
-    await ensureDir(path.dirname(globalPath));
-    if (!(await exists(globalPath))) {
-        await writeFileSafe(globalPath, "");
+        await writeFileSafe(storePath, "# Project Knowledge\n\n");
     }
 }
 async function ensureSessionStateFiles(projectRoot) {
@@ -723,6 +684,20 @@ async function cleanLegacyArtifacts(projectRoot) {
             // best-effort cleanup
         }
     }
+    for (const legacyRuntimeFile of [
+        runtimePath(projectRoot, "learnings.jsonl"),
+        runtimePath(projectRoot, "observations.jsonl"),
+        runtimePath(projectRoot, "hooks", "observe.sh"),
+        runtimePath(projectRoot, "hooks", "summarize-observations.sh"),
+        runtimePath(projectRoot, "hooks", "summarize-observations.mjs")
+    ]) {
+        try {
+            await fs.rm(legacyRuntimeFile, { force: true });
+        }
+        catch {
+            // best-effort cleanup
+        }
+    }
 }
 async function cleanStaleFiles(projectRoot) {
     const expectedShimFiles = new Set([
@@ -769,8 +744,7 @@ async function materializeRuntime(projectRoot, config, forceStateReset) {
     await ensureRunSystem(projectRoot, { createIfMissing: false });
     await ensureSessionStateFiles(projectRoot);
     await writeAdapterManifest(projectRoot, harnesses);
-    await ensureLearningsStore(projectRoot);
-    await ensureGlobalLearningsStore(projectRoot, config);
+    await ensureKnowledgeStore(projectRoot);
     await writeHooks(projectRoot, config);
     await syncDisabledHarnessArtifacts(projectRoot, harnesses);
     await syncManagedGitHooks(projectRoot, config);
@@ -854,7 +828,7 @@ function stripManagedHookCommands(value) {
 }
 function isManagedRuntimeHookCommand(command) {
     const normalized = command.trim().replace(/\s+/gu, " ");
-    return /(^|\s)(?:bash\s+)?(?:\.\/)?\.cclaw\/hooks\/(?:session-start|stop-checkpoint|prompt-guard|workflow-guard|context-monitor|observe|summarize-observations)\.sh(?:\s|$)/u.test(normalized);
+    return /(^|\s)(?:bash\s+)?(?:\.\/)?\.cclaw\/hooks\/(?:session-start|stop-checkpoint|prompt-guard|workflow-guard|context-monitor)\.sh(?:\s|$)/u.test(normalized);
 }
 async function removeManagedHookEntries(hookFilePath) {
     if (!(await exists(hookFilePath)))

package/dist/policy.js

@@ -85,9 +85,8 @@ export async function policyChecks(projectRoot, options = {}) {
     // --- utility skill checks ---
     const runtimeFile = (relativePath) => `${RUNTIME_ROOT}/${relativePath}`;
     const utilitySkillChecks = [
-        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## Learning Entry Schema", name: "utility_skill:learnings:schema" },
+        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## Entry format (append-only)", name: "utility_skill:learnings:entry_format" },
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## Subcommands", name: "utility_skill:learnings:subcommands" },
-        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## Confidence Decay", name: "utility_skill:learnings:decay" },
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:learnings:hard_gate" },
         { file: runtimeFile("commands/learn.md"), needle: "## Subcommands", name: "utility_command:learn:subcommands" },
         { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:sdd:hard_gate" },
@@ -152,8 +151,6 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("hooks/workflow-guard.sh"), needle: "stage_invocation_without_recent_flow_read", name: "hooks:workflow_guard:flow_read_reason" },
         { file: runtimeFile("hooks/workflow-guard.sh"), needle: "stage_jump_", name: "hooks:workflow_guard:stage_jump_reason" },
         { file: runtimeFile("hooks/context-monitor.sh"), needle: "remaining is", name: "hooks:context:threshold_warning" },
-        { file: runtimeFile("hooks/observe.sh"), needle: "stage-activity.jsonl", name: "hooks:observe:activity_write" },
-        { file: runtimeFile("hooks/summarize-observations.mjs"), needle: "frequent-errors-", name: "hooks:summarize:runtime_module" },
         { file: runtimeFile("hooks/opencode-plugin.mjs"), needle: "activeRunId", name: "hooks:opencode:active_run" }
     ];
     if (activeHarnesses.has("opencode")) {

package/dist/runs.d.ts

@@ -3,20 +3,20 @@ export interface CclawRunMeta {
     id: string;
     title: string;
     createdAt: string;
-    archivedAt?: string;
-    stateSnapshot?: Omit<FlowState, "activeRunId">;
+}
+export interface ArchiveRunResult {
+    archiveId: string;
+    archivePath: string;
+    archivedAt: string;
+    featureName: string;
+    resetState: FlowState;
 }
 interface EnsureRunSystemOptions {
     createIfMissing?: boolean;
 }
 export declare function readFlowState(projectRoot: string): Promise<FlowState>;
 export declare function writeFlowState(projectRoot: string, state: FlowState): Promise<void>;
+export declare function ensureRunSystem(projectRoot: string, _options?: EnsureRunSystemOptions): Promise<FlowState>;
 export declare function listRuns(projectRoot: string): Promise<CclawRunMeta[]>;
-export declare function ensureRunSystem(projectRoot: string, options?: EnsureRunSystemOptions): Promise<FlowState>;
-export declare function startNewFeatureRun(projectRoot: string, title?: string): Promise<CclawRunMeta>;
-export declare function resumeRun(projectRoot: string, runId: string): Promise<CclawRunMeta>;
-export declare function archiveRun(projectRoot: string, runId?: string): Promise<{
-    archived: CclawRunMeta;
-    active: CclawRunMeta;
-}>;
+export declare function archiveRun(projectRoot: string, featureName?: string): Promise<ArchiveRunResult>;
 export {};