@hmharness/agent 0.23.23 → 0.23.25

package/dist/code-wm-live.d.ts

@@ -0,0 +1,44 @@
+import type { CodeWorldModel } from '@hmharness/cognitive';
+import type { LspClient, Diagnostic } from '@hmharness/lsp';
+export interface LiveCodeWmSensorOptions {
+    workspaceRoot: string;
+    languageId?: string;
+}
+export declare class LiveCodeWmSensor {
+    private client;
+    private cwm;
+    private opts;
+    private diagPushes;
+    private lastSyncAt;
+    private tracked;
+    constructor(client: LspClient, cwm: CodeWorldModel, opts: LiveCodeWmSensorOptions);
+    /**
+     * Full sync for one file: open the doc on the server (triggers analysis),
+     * pull symbols, pull diagnostics from the model's sensor state, push both
+     * into the Code WM. Returns the ingested counts.
+     */
+    syncFile(absPath: string, text: string): Promise<{
+        entitiesIngested: number;
+        relationsIngested: number;
+        diagnosticsIngested: number;
+    }>;
+    /** Pull the CURRENT diagnostics for a uri from the model's sensor state.
+     *  Range-restored: the Code WM keeps message-level state (no ranges);
+     *  zero ranges are the honest placeholder for sensor re-reads, never a
+     *  fabricated location. */
+    pullDiagnostics(uri: string): Diagnostic[];
+    get stats(): {
+        tracked: number;
+        diagPushes: number;
+        lastSyncAt: string | null;
+    };
+    /** Sync many files (workspace scan path). */
+    syncFiles(files: Array<{
+        path: string;
+        text: string;
+    }>): Promise<{
+        entitiesIngested: number;
+        relationsIngested: number;
+        diagnosticsIngested: number;
+    }>;
+}

package/dist/code-wm-live.js

@@ -0,0 +1,72 @@
+/**
+ * @hmharness/agent - live LSP sensor → Code World Model bridge (audit line B)
+ *
+ * The mapping functions (lspSymbolsToOntology etc.) are pure; THIS class
+ * makes them LIVE: an LspClient's push stream (diagnostics) and pull
+ * results (documentSymbols) flow into a CodeWorldModel continuously, with
+ * openDoc() driving the server to analyze the file in the first place.
+ *
+ * Usage: create with a connected LspClient + a CodeWorldModel + the
+ * workspace root; call syncFile(uri, text) after each edit the agent makes
+ * — the model then carries a current code world for the slice/MEA/digest
+ * layers to reason over.
+ */
+import { join } from 'node:path';
+import { fileToUri } from '@hmharness/lsp';
+import { syncCodeWorldModel } from "./code-wm-sensor.js";
+export class LiveCodeWmSensor {
+    client;
+    cwm;
+    opts;
+    diagPushes = 0;
+    lastSyncAt = null;
+    tracked = new Set();
+    constructor(client, cwm, opts) {
+        this.client = client;
+        this.cwm = cwm;
+        this.opts = opts;
+    }
+    /**
+     * Full sync for one file: open the doc on the server (triggers analysis),
+     * pull symbols, pull diagnostics from the model's sensor state, push both
+     * into the Code WM. Returns the ingested counts.
+     */
+    async syncFile(absPath, text) {
+        const uri = fileToUri(absPath);
+        this.client.openDoc(uri, this.opts.languageId ?? 'typescript', text);
+        const symbols = await this.client.documentSymbols({ uri }).catch(() => []);
+        const diagnostics = this.pullDiagnostics(uri);
+        const result = syncCodeWorldModel(this.cwm, { uri, symbols, diagnostics });
+        this.diagPushes += result.diagnosticsIngested;
+        this.lastSyncAt = new Date().toISOString();
+        this.tracked.add(uri);
+        return result;
+    }
+    /** Pull the CURRENT diagnostics for a uri from the model's sensor state.
+     *  Range-restored: the Code WM keeps message-level state (no ranges);
+     *  zero ranges are the honest placeholder for sensor re-reads, never a
+     *  fabricated location. */
+    pullDiagnostics(uri) {
+        const diags = this.cwm.diagnosticsFor(uri);
+        return diags.map((d) => ({
+            range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } },
+            severity: (d.severity ?? 1),
+            message: d.message,
+            source: 'cwm',
+        }));
+    }
+    get stats() {
+        return { tracked: this.tracked.size, diagPushes: this.diagPushes, lastSyncAt: this.lastSyncAt };
+    }
+    /** Sync many files (workspace scan path). */
+    async syncFiles(files) {
+        const total = { entitiesIngested: 0, relationsIngested: 0, diagnosticsIngested: 0 };
+        for (const f of files) {
+            const r = await this.syncFile(join(this.opts.workspaceRoot, f.path), f.text);
+            total.entitiesIngested += r.entitiesIngested;
+            total.relationsIngested += r.relationsIngested;
+            total.diagnosticsIngested += r.diagnosticsIngested;
+        }
+        return total;
+    }
+}

package/dist/code-wm-recorder.d.ts

@@ -1,22 +1,22 @@
-/**
- * @hmharness/agent - Code World Model recorder (production sensor wiring)
- *
- * Round 38 closes the loop the sensors were waiting for: extension page
- * observations now reach a PERSISTED Code World Model. The recorder is a
- * lazy per-home singleton — the first observation loads the model from
- * HMH_HOME, the sensor feeds it, and a debounce flushes to disk. The LSP
- * sensor (round 35) rides the same store once its tools gain an event
- * hook; until then it stays library-only, honestly.
- *
- * Failure posture: everything best-effort — a storage error logs nothing
- * and never breaks the tool that observed the page (evidence must not be
- * able to kill the work it evidences). A crash loses at most one debounce
- * window of observations.
- */
 import { type CodeWorldModel } from '@hmharness/cognitive';
 import type { RawPageData } from '@hmharness/extension';
+import type { Tool } from '@hmharness/kernel';
+import { type CodeWorldSyncInput } from './code-wm-sensor.js';
 /** The onPageRead hook handed to extensionTools — one closure per home. */
 export declare function pageReadSink(home: string): (raw: RawPageData) => void;
+/** The onObserve hook handed to lspTools — the LSP tools' read-only pulls
+ *  become durable Code WM evidence, same store, same debounce. */
+export declare function lspObserveSink(home: string): (obs: CodeWorldSyncInput) => void;
+/** Build facts replace (the model keeps only the LATEST build verdict). */
+export declare function buildSink(home: string): (fact: {
+    ok: boolean;
+    outputDigest?: string;
+}) => void;
+/** Registry-assembly wrapper (round 44): the harmony build tools gain a
+ *  build-fact observation without the domain package learning about
+ *  cognitive. The wrap never alters the tool's result; a sink error is
+ *  swallowed (the observation must not fail the work it evidences). */
+export declare function observeBuildTools(tools: Tool[], home: string): Tool[];
 /** Test isolation: drop caches + pending timers (never used in production). */
 export declare function resetCodeWorldRecorder(): void;
 /** Introspection for tests/status surfaces: the live model for a home. */

package/dist/code-wm-recorder.js

@@ -1,29 +1,74 @@
 /**
  * @hmharness/agent - Code World Model recorder (production sensor wiring)
  *
- * Round 38 closes the loop the sensors were waiting for: extension page
- * observations now reach a PERSISTED Code World Model. The recorder is a
- * lazy per-home singleton — the first observation loads the model from
- * HMH_HOME, the sensor feeds it, and a debounce flushes to disk. The LSP
- * sensor (round 35) rides the same store once its tools gain an event
- * hook; until then it stays library-only, honestly.
+ * Round 38 closed the loop for extension page observations; round 43 adds
+ * the LSP side (lspTools onObserve → symbols/diagnostics); round 44 adds
+ * the build side: the harmony build tools' results become the model's
+ * LATEST BuildFact, wrapped at registry assembly so the domain package
+ * stays single-minded (kernel-only deps — the audit's composition-layer
+ * rule). All three families share the lazy per-home singleton and one
+ * debounced flush. LiveCodeWmSensor remains the wrapper for callers that
+ * own a client and want file-driven syncs; the tool-hook paths share the
+ * ingestion core.
  *
  * Failure posture: everything best-effort — a storage error logs nothing
  * and never breaks the tool that observed the page (evidence must not be
  * able to kill the work it evidences). A crash loses at most one debounce
  * window of observations.
  */
+import { createHash } from 'node:crypto';
 import { loadCodeWorldModel, saveCodeWorldModel } from '@hmharness/cognitive';
 import { syncExtensionRuntime } from "./extension-wm-sensor.js";
+import { syncCodeWorldModel } from "./code-wm-sensor.js";
 const SAVE_DEBOUNCE_MS = 2_000;
 const entries = new Map();
 /** The onPageRead hook handed to extensionTools — one closure per home. */
 export function pageReadSink(home) {
     return (raw) => {
-        void observe(home, raw);
+        void mutate(home, (cwm) => syncExtensionRuntime(cwm, raw));
     };
 }
-async function observe(home, raw) {
+/** The onObserve hook handed to lspTools — the LSP tools' read-only pulls
+ *  become durable Code WM evidence, same store, same debounce. */
+export function lspObserveSink(home) {
+    return (obs) => {
+        if (!obs.symbols?.length && !obs.diagnostics?.length)
+            return;
+        void mutate(home, (cwm) => syncCodeWorldModel(cwm, obs));
+    };
+}
+/** Build facts replace (the model keeps only the LATEST build verdict). */
+export function buildSink(home) {
+    return (fact) => {
+        void mutate(home, (cwm) => cwm.ingest({ build: { ok: fact.ok, ...(fact.outputDigest ? { outputDigest: fact.outputDigest } : {}), at: new Date().toISOString() } }));
+    };
+}
+/** Registry-assembly wrapper (round 44): the harmony build tools gain a
+ *  build-fact observation without the domain package learning about
+ *  cognitive. The wrap never alters the tool's result; a sink error is
+ *  swallowed (the observation must not fail the work it evidences). */
+export function observeBuildTools(tools, home) {
+    const sink = buildSink(home);
+    return tools.map((t) => {
+        if (t.name !== 'harmony_build' && t.name !== 'harmony_cjpm_build')
+            return t;
+        const orig = t.execute.bind(t);
+        const wrapped = {
+            ...t,
+            async execute(args, ctx) {
+                const r = await orig(args, ctx);
+                try {
+                    const out = typeof r.output === 'string' ? r.output : '';
+                    sink({ ok: !r.isError, ...(out ? { outputDigest: createHash('sha256').update(out).digest('hex').slice(0, 16) } : {}) });
+                }
+                catch { /* observation must never fail the tool */ }
+                return r;
+            },
+        };
+        return wrapped;
+    });
+}
+async function mutate(home, fn) {
     try {
         let entry = entries.get(home);
         if (!entry) {
@@ -31,7 +76,7 @@ async function observe(home, raw) {
             entries.set(home, entry);
         }
         const cwm = await entry.load;
-        syncExtensionRuntime(cwm, raw);
+        fn(cwm);
         entry.dirty = true;
         if (!entry.timer) {
             entry.timer = setTimeout(() => {

package/dist/runner.js

@@ -18,7 +18,7 @@ import { opsTools } from '@hmharness/domain-ops';
 import { discoverServers, lspTools } from '@hmharness/lsp';
 import { discoverBrowsers, browserTools } from '@hmharness/browser';
 import { discoverExtensionBridgeSync, extensionTools } from '@hmharness/extension';
-import { pageReadSink } from "./code-wm-recorder.js";
+import { pageReadSink, lspObserveSink, observeBuildTools } from "./code-wm-recorder.js";
 import * as readline from 'node:readline/promises';
 import { stdin } from 'node:process';
 import { baseTools } from "./tools.js";
@@ -39,7 +39,7 @@ export function toServerConfig(c) {
 export const spawnBase = {};
 export function nativeRegistry(depth, opts = {}) {
     const reg = new Registry();
-    reg.registerAll(baseTools).registerAll(harmonyTools).registerAll(opsTools);
+    reg.registerAll(baseTools).registerAll(observeBuildTools(harmonyTools, homeDir())).registerAll(opsTools);
     // W6: LSP Tier-0 code-intelligence tools — registered ONLY when a real
     // server is discoverable on PATH; a machine with no language servers
     // must not carry dead tools. Discovery is synchronous (memoized PATH
@@ -49,7 +49,11 @@ export function nativeRegistry(depth, opts = {}) {
             // healthy-only: a PATH shim whose toolchain lacks the component would
             // register a tool that always errors — skip it, keep the registry honest
             if (discoverServers().some((s) => s.healthy)) {
-                reg.registerAll(lspTools({ workspaceRoot: opts.workspaceRoot ?? process.cwd(), home: homeDir() }));
+                // onObserve feeds the PERSISTED Code World Model (round 43): every
+                // lsp_symbols/lsp_diagnostics pull becomes durable entity/relation/
+                // diagnostic evidence — best-effort, same store as the extension
+                // recorder, never able to fail the tool that observed.
+                reg.registerAll(lspTools({ workspaceRoot: opts.workspaceRoot ?? process.cwd(), home: homeDir(), onObserve: lspObserveSink(homeDir()) }));
             }
         }
         catch { /* lsp optional: never block tool assembly */ }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hmharness/agent",
-  "version": "0.23.23",
+  "version": "0.23.25",
   "description": "hmharness agent execution layer: base tools, system prompt, sub-agent spawn, and the shared task runner that frontends (cli, web) drive.",
   "type": "module",
   "main": "dist/index.js",
@@ -15,16 +15,16 @@
     "build": "tsc -p tsconfig.build.json"
   },
   "dependencies": {
-    "@hmharness/cognitive": "0.23.23",
-    "@hmharness/domain-harmony": "0.23.23",
-    "@hmharness/domain-ops": "0.23.23",
-    "@hmharness/evolution": "0.23.23",
-    "@hmharness/kernel": "0.23.23",
-    "@hmharness/observability": "0.23.23",
-    "@hmharness/sandbox": "0.23.23",
-    "@hmharness/lsp": "0.23.23",
-    "@hmharness/browser": "0.23.23",
-    "@hmharness/extension": "0.23.23"
+    "@hmharness/cognitive": "0.23.25",
+    "@hmharness/domain-harmony": "0.23.25",
+    "@hmharness/domain-ops": "0.23.25",
+    "@hmharness/evolution": "0.23.25",
+    "@hmharness/kernel": "0.23.25",
+    "@hmharness/observability": "0.23.25",
+    "@hmharness/sandbox": "0.23.25",
+    "@hmharness/lsp": "0.23.25",
+    "@hmharness/browser": "0.23.25",
+    "@hmharness/extension": "0.23.25"
   },
   "files": [
     "dist"