@hmharness/agent 0.23.22 → 0.23.24

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

@@ -0,0 +1,23 @@
+/**
+ * @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';
+/** The onPageRead hook handed to extensionTools — one closure per home. */
+export declare function pageReadSink(home: string): (raw: RawPageData) => void;
+/** 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. */
+export declare function liveCodeWorldModel(home: string): Promise<CodeWorldModel | null>;

package/dist/code-wm-recorder.js

@@ -0,0 +1,71 @@
+/**
+ * @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 { loadCodeWorldModel, saveCodeWorldModel } from '@hmharness/cognitive';
+import { syncExtensionRuntime } from "./extension-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);
+    };
+}
+async function observe(home, raw) {
+    try {
+        let entry = entries.get(home);
+        if (!entry) {
+            entry = { load: loadCodeWorldModel(home), dirty: false, timer: null };
+            entries.set(home, entry);
+        }
+        const cwm = await entry.load;
+        syncExtensionRuntime(cwm, raw);
+        entry.dirty = true;
+        if (!entry.timer) {
+            entry.timer = setTimeout(() => {
+                if (!entry)
+                    return;
+                entry.timer = null;
+                void flush(home);
+            }, SAVE_DEBOUNCE_MS);
+        }
+    }
+    catch { /* observation is best-effort by contract */ }
+}
+async function flush(home) {
+    const entry = entries.get(home);
+    if (!entry || !entry.dirty)
+        return;
+    entry.dirty = false;
+    try {
+        const cwm = await entry.load;
+        await saveCodeWorldModel(home, cwm);
+    }
+    catch {
+        entry.dirty = true; // keep the evidence for the next flush
+    }
+}
+/** Test isolation: drop caches + pending timers (never used in production). */
+export function resetCodeWorldRecorder() {
+    for (const [, e] of entries)
+        if (e.timer)
+            clearTimeout(e.timer);
+    entries.clear();
+}
+/** Introspection for tests/status surfaces: the live model for a home. */
+export async function liveCodeWorldModel(home) {
+    const entry = entries.get(home);
+    return entry ? entry.load : null;
+}

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

@@ -0,0 +1,41 @@
+/**
+ * @hmharness/agent - LSP → Code World Model sensor wiring (audit line B)
+ *
+ * "LSP 提供 symbol/definition/reference/... 结构化观察，可作为 Code World
+ * Model 的传感器；不要把它做成 IDE" (02 doc). This adapter lives in agent
+ * — the composition layer that already depends on BOTH @hmharness/lsp and
+ * @hmharness/cognitive — so neither layering direction is violated.
+ *
+ * Mapping (LSP 3.18 shapes → audit ontology):
+ *   DocumentSymbol tree → CodeEntity per symbol + 'defines' relation per
+ *     parent→child edge (the only relation LSP symbols PROVE; calls/
+ *     references need deeper requests — later sensors)
+ *   publishDiagnostics payload → CodeDiagnostic (source: 'lsp' — the
+ *     feedback-not-proof label travels into the model)
+ *   BuildFact/RuntimeFact have their own sensors (build tool, runs) —
+ *     not this adapter's job.
+ */
+import { CodeWorldModel, type CodeDiagnostic, type CodeEntity, type SymbolRelation } from '@hmharness/cognitive';
+import type { Diagnostic, DocumentSymbol } from '@hmharness/lsp';
+/**
+ * LSP DocumentSymbol tree → entities + 'defines' relations. Nested children
+ * become defines edges (a document defines its top-level symbols; a class
+ * defines its methods). Only what the symbols response PROVES is emitted.
+ */
+export declare function lspSymbolsToOntology(uri: string, symbols: DocumentSymbol[]): {
+    entities: CodeEntity[];
+    relations: SymbolRelation[];
+};
+/** LSP diagnostics payload → audit CodeDiagnostic (source pinned to 'lsp'). */
+export declare function lspDiagnosticsToOntology(uri: string, diagnostics: Diagnostic[]): CodeDiagnostic[];
+export interface CodeWorldSyncInput {
+    uri: string;
+    symbols?: DocumentSymbol[];
+    diagnostics?: Diagnostic[];
+}
+/** One sensor sync: symbols + diagnostics from LSP into the model. */
+export declare function syncCodeWorldModel(cwm: CodeWorldModel, input: CodeWorldSyncInput): {
+    entitiesIngested: number;
+    relationsIngested: number;
+    diagnosticsIngested: number;
+};

package/dist/code-wm-sensor.js

@@ -0,0 +1,69 @@
+/** Map a LSP symbol kind number to the audit's entity kind (best effort). */
+function entityKind(symbolKind) {
+    // LTS subset of LSP SymbolKind; unknown kinds land as 'field' — honest
+    // coarseness beats a wrong specific kind (the audit ontology has no
+    // 'property' kind — methods/fields cover the LSP property case)
+    if (symbolKind === 12)
+        return 'function';
+    if (symbolKind === 5)
+        return 'class';
+    if (symbolKind === 6)
+        return 'method';
+    if (symbolKind === 2)
+        return 'module';
+    if (symbolKind === 1)
+        return 'file';
+    return 'field';
+}
+/**
+ * LSP DocumentSymbol tree → entities + 'defines' relations. Nested children
+ * become defines edges (a document defines its top-level symbols; a class
+ * defines its methods). Only what the symbols response PROVES is emitted.
+ */
+export function lspSymbolsToOntology(uri, symbols) {
+    const entities = [];
+    const relations = [];
+    const walk = (list, parentId) => {
+        for (const s of list) {
+            const id = `${uri}#${s.name}`;
+            entities.push({
+                id,
+                kind: entityKind(s.kind),
+                name: s.name,
+                uri,
+                ...(s.range?.start ? { range: { startLine: s.range.start.line + 1, endLine: (s.range.end?.line ?? s.range.start.line) + 1 } } : {}),
+            });
+            if (parentId)
+                relations.push({ from: parentId, to: id, kind: 'defines' });
+            if (s.children?.length)
+                walk(s.children, id);
+        }
+    };
+    walk(symbols, null);
+    return { entities, relations };
+}
+/** LSP diagnostics payload → audit CodeDiagnostic (source pinned to 'lsp'). */
+export function lspDiagnosticsToOntology(uri, diagnostics) {
+    return diagnostics.map((d) => ({
+        uri,
+        severity: (d.severity ?? 1),
+        message: d.message,
+        source: 'lsp', // the feedback-not-proof label rides into the model
+    }));
+}
+/** One sensor sync: symbols + diagnostics from LSP into the model. */
+export function syncCodeWorldModel(cwm, input) {
+    const result = { entitiesIngested: 0, relationsIngested: 0, diagnosticsIngested: 0 };
+    if (input.symbols?.length) {
+        const { entities, relations } = lspSymbolsToOntology(input.uri, input.symbols);
+        cwm.ingest({ entities, relations });
+        result.entitiesIngested = entities.length;
+        result.relationsIngested = relations.length;
+    }
+    if (input.diagnostics) {
+        const diags = lspDiagnosticsToOntology(input.uri, input.diagnostics);
+        cwm.ingest({ diagnostics: diags });
+        result.diagnosticsIngested = diags.length;
+    }
+    return result;
+}

package/dist/extension-wm-sensor.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @hmharness/agent - browser-extension → Code World Model runtime sensor
+ *
+ * The audit ontology's RuntimeFact ("runs" sensor) gets its first source:
+ * the user's REAL browser. Every extension_page_read observation lands as
+ * runtime facts — where the agent looked and what the user had selected.
+ * Like the LSP sensor (code-wm-sensor.ts, round 35), this adapter lives
+ * in agent — the composition layer that already depends on BOTH
+ * @hmharness/extension and @hmharness/cognitive — so neither layering
+ * direction is violated, and the mapping is a library call waiting for
+ * the model's persistence wiring (same honest posture as round 35).
+ *
+ * Mapping discipline (honest, bounded):
+ *   every page read   → ONE RuntimeFact kind 'ext.page.read'
+ *                       (title — url, capped; the identity is the URL)
+ *   non-empty selection → ONE kind 'ext.page.selection' (user-intent
+ *                       signal — the human highlighted this text while
+ *                       the agent was working)
+ *   nothing else      → headings/links/text are CONTEXT for the loop's
+ *                       turn, not durable facts; flooding the model with
+ *                       per-heading facts would be noise dressed as
+ *                       evidence.
+ */
+import { CodeWorldModel, type RuntimeFact } from '@hmharness/cognitive';
+import type { RawPageData } from '@hmharness/extension';
+/** Page observation → audit RuntimeFacts (pure; no DOM, no I/O). */
+export declare function pageReadToRuntimeFacts(raw: RawPageData, at?: string): RuntimeFact[];
+export interface RuntimeSyncResult {
+    factsIngested: number;
+}
+/** One sensor sync: extension page observation → runtime facts. */
+export declare function syncExtensionRuntime(cwm: CodeWorldModel, raw: RawPageData): RuntimeSyncResult;

package/dist/extension-wm-sensor.js

@@ -0,0 +1,21 @@
+const clip = (s, n) => {
+    const t = String(s ?? '').replace(/\s+/g, ' ').trim();
+    return t.length > n ? t.slice(0, n) : t;
+};
+/** Page observation → audit RuntimeFacts (pure; no DOM, no I/O). */
+export function pageReadToRuntimeFacts(raw, at = new Date().toISOString()) {
+    const title = clip(raw.title, 120);
+    const url = clip(raw.url, 300);
+    const facts = [{ kind: 'ext.page.read', detail: title ? `${title} — ${url}` : url, at }];
+    const selection = clip(raw.selection, 200);
+    if (selection)
+        facts.push({ kind: 'ext.page.selection', detail: selection, at });
+    return facts;
+}
+/** One sensor sync: extension page observation → runtime facts. */
+export function syncExtensionRuntime(cwm, raw) {
+    const facts = pageReadToRuntimeFacts(raw);
+    for (const f of facts)
+        cwm.ingest({ runtime: f });
+    return { factsIngested: facts.length };
+}

package/dist/i18n.d.ts

@@ -139,6 +139,10 @@ export interface Strings {
     opsHint: string;
     tuiLongOutputHint: (tool: string, lines: number) => string;
     tuiUserFolded: (hidden: number) => string;
+    /** update briefing trio (T27-v2): start line, completion line, first-launch note */
+    tuiUpdating: (v: string) => string;
+    tuiUpdated: (v: string) => string;
+    tuiBriefing: (v: string, note: string) => string;
     tuiAutoUpdateFailed: (why: string) => string;
     tuiEvolveDone: (proposals: number, insights: number, notes: number) => string;
     tuiPassRate: (pct: string) => string;

package/dist/i18n.js

@@ -114,6 +114,9 @@ const zh = {
     opsHint: '更多操作:/ops scan 立即扫描并生成今日简报 · /ops brief 查看最近简报',
     tuiLongOutputHint: (tool, lines) => `⎿ ${tool} 输出 ${lines} 行(已折叠) · 按 z 展开最后一条 · Ctrl+T 看全文`,
     tuiUserFolded: (hidden) => `(…还有 ${hidden} 行已折叠 · Ctrl+T 看全文)`,
+    tuiUpdating: (v) => `⤴ 发现新版本 ${v}，后台更新中（不打扰当前会话，新版本下次启动生效）`,
+    tuiUpdated: (v) => `✓ 已更新到 ${v} · 重启 hmh 后生效`,
+    tuiBriefing: (v, note) => `📋 本次更新 ${v}：${note}`,
     tuiAutoUpdateFailed: (why) => `⤴ 自动更新未能开始(${why})，下次再试;或手动: npm i -g @hmharness/cli@latest`,
     tuiEvolveDone: (p, i, n) => `evolve 完成: ${p} 提案 · 洞察 ${i} · 记忆 ${n}`,
     tuiPassRate: (pct) => `pass rate: ${pct}`,
@@ -267,6 +270,9 @@ const en = {
     opsHint: 'more: /ops scan pull upstream + write today brief · /ops brief latest brief',
     tuiLongOutputHint: (tool, lines) => `⎿ ${tool} produced ${lines} lines (folded) · z expands the last cell · Ctrl+T full transcript`,
     tuiUserFolded: (hidden) => `(…${hidden} more lines folded · Ctrl+T full transcript)`,
+    tuiUpdating: (v) => `⤴ new version ${v} - updating in the background (this session is unaffected; effective on next launch)`,
+    tuiUpdated: (v) => `✓ updated to ${v} · restart hmh to activate`,
+    tuiBriefing: (v, note) => `📋 updated ${v}: ${note}`,
     tuiAutoUpdateFailed: (why) => `⤴ auto-update could not start (${why}); or manually: npm i -g @hmharness/cli@latest`,
     tuiEvolveDone: (p, i, n) => `evolve done: ${p} proposals · ${i} insights · ${n} notes`,
     tuiPassRate: (pct) => `pass rate: ${pct}`,

package/dist/index.d.ts

@@ -1,13 +1,13 @@
-export { baseTools, readFileTool, writeFileTool, listDirTool, runCommandTool, rememberTool, seeImageTool } from './tools.ts';
-export { manifestFor, capabilityReport, authorize, type CapabilityManifest, type CapabilityRisk, type PolicyMode } from './capability.ts';
-export { checkpointProject, createProject, findProject, interruptProject, listProjects, loadProject, projectFor, releaseProject, restoreCheckpoint, resumeBundle, transitionProject, attachRun, newProjectId, type CheckpointRef, type DecisionEntry, type ProjectRecord, type ProjectState, } from './project.ts';
-export { mechanicalGate, parseVerdict, runPipeline, type PipelineOptions, type PipelineReport, type StageRecord, type StageRole, } from './pipeline.ts';
-export { buildSystemPrompt } from './prompt.ts';
-export { strings, type Locale, type Strings } from './i18n.ts';
-export { makeSpawnTool, MAX_SPAWN_DEPTH, type SpawnBase } from './spawn.ts';
-export { withTopologyGovernance, mapRole, liveTopologySnapshot, teamLog } from './topology-live.ts';
-export { buildRegistry, contextPack, makeApproval, liveYolo, nativeRegistry, runAgentTask, spawnBase, toServerConfig, type AgentTaskOptions, type RunnerEvents, } from './runner.ts';
-export * from './skills-conformance.ts';
-export * from './acp.ts';
-export * from './topology.ts';
-export * from './meta-harness.ts';
+export { baseTools, readFileTool, writeFileTool, listDirTool, runCommandTool, rememberTool, seeImageTool } from './tools.js';
+export { manifestFor, capabilityReport, authorize, type CapabilityManifest, type CapabilityRisk, type PolicyMode } from './capability.js';
+export { checkpointProject, createProject, findProject, interruptProject, listProjects, loadProject, projectFor, releaseProject, restoreCheckpoint, resumeBundle, transitionProject, attachRun, newProjectId, type CheckpointRef, type DecisionEntry, type ProjectRecord, type ProjectState, } from './project.js';
+export { mechanicalGate, parseVerdict, runPipeline, type PipelineOptions, type PipelineReport, type StageRecord, type StageRole, } from './pipeline.js';
+export { buildSystemPrompt } from './prompt.js';
+export { strings, type Locale, type Strings } from './i18n.js';
+export { makeSpawnTool, MAX_SPAWN_DEPTH, type SpawnBase } from './spawn.js';
+export { withTopologyGovernance, mapRole, liveTopologySnapshot, teamLog } from './topology-live.js';
+export { buildRegistry, contextPack, makeApproval, liveYolo, nativeRegistry, runAgentTask, spawnBase, toServerConfig, type AgentTaskOptions, type RunnerEvents, } from './runner.js';
+export * from './skills-conformance.js';
+export * from './acp.js';
+export * from './topology.js';
+export * from './meta-harness.js';

package/dist/runner.d.ts

@@ -8,7 +8,7 @@
 import { Registry, type ChatMessage, type DeltaKind, type HmhConfig, type LoopApproval, type LoopResult, type McpClient, type McpServerConfig, type McpServerImport, type ToolContext } from '@hmharness/kernel';
 import { type EmbeddingProvider } from '@hmharness/evolution';
 import * as readline from 'node:readline/promises';
-import { type SpawnBase } from './spawn.ts';
+import { type SpawnBase } from './spawn.js';
 /** Flatten the config.json shape into the runtime discriminated union. */
 export declare function toServerConfig(c: McpServerImport): McpServerConfig;
 /**
@@ -21,6 +21,7 @@ export declare const spawnBase: {
 export declare function nativeRegistry(depth: number, opts?: {
     lsp?: boolean;
     browser?: boolean;
+    extension?: boolean;
     workspaceRoot?: string;
 }): Registry;
 export declare function buildRegistry(opts?: {

package/dist/runner.js

@@ -17,6 +17,8 @@ import { harmonyTools } from '@hmharness/domain-harmony';
 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 * as readline from 'node:readline/promises';
 import { stdin } from 'node:process';
 import { baseTools } from "./tools.js";
@@ -65,6 +67,24 @@ export function nativeRegistry(depth, opts = {}) {
         }
         catch { /* browser optional: never block tool assembly */ }
     }
+    // extension_* family (2026-10-04, ChatGPT-style browser-extension bridge)
+    // — the user's REAL browser via the paired extension. Same dead-tools
+    // rule, but liveness is a STATE FILE the bridge keeps fresh (registry
+    // build stays sync); registration additionally requires an extension
+    // to be CONNECTED right now, and the tools themselves re-check the
+    // bridge over HTTP on every call.
+    if (opts.extension !== false) {
+        try {
+            const bridge = discoverExtensionBridgeSync(homeDir());
+            if (bridge.healthy && bridge.connected) {
+                // onPageRead feeds the PERSISTED Code World Model (round 38):
+                // every real-browser page observation becomes durable RuntimeFact
+                // evidence — best-effort, never able to fail the tool itself.
+                reg.registerAll(extensionTools({ home: homeDir(), onPageRead: pageReadSink(homeDir()) }));
+            }
+        }
+        catch { /* extension optional: never block tool assembly */ }
+    }
     if (depth < MAX_SPAWN_DEPTH) {
         // blueprint M10: every spawn_agent is governed by the live topology
         // (role contract + shared budget + immutable multi-agent.jsonl audit);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hmharness/agent",
-  "version": "0.23.22",
+  "version": "0.23.24",
   "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,15 +15,16 @@
     "build": "tsc -p tsconfig.build.json"
   },
   "dependencies": {
-    "@hmharness/cognitive": "0.23.22",
-    "@hmharness/domain-harmony": "0.23.22",
-    "@hmharness/domain-ops": "0.23.22",
-    "@hmharness/evolution": "0.23.22",
-    "@hmharness/kernel": "0.23.22",
-    "@hmharness/observability": "0.23.22",
-    "@hmharness/sandbox": "0.23.22",
-    "@hmharness/lsp": "0.23.22",
-    "@hmharness/browser": "0.23.22"
+    "@hmharness/cognitive": "0.23.24",
+    "@hmharness/domain-harmony": "0.23.24",
+    "@hmharness/domain-ops": "0.23.24",
+    "@hmharness/evolution": "0.23.24",
+    "@hmharness/kernel": "0.23.24",
+    "@hmharness/observability": "0.23.24",
+    "@hmharness/sandbox": "0.23.24",
+    "@hmharness/lsp": "0.23.24",
+    "@hmharness/browser": "0.23.24",
+    "@hmharness/extension": "0.23.24"
   },
   "files": [
     "dist"