@hmharness/agent 0.23.21 → 0.23.23

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/runner.d.ts

@@ -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/dist/tools.js

@@ -493,7 +493,7 @@ export const desktopTypeTool = {
  */
 export const browserOpenTool = {
     name: 'browser_open',
-    description: 'Open a URL in the user\'s default browser (visible). Then use desktop_screenshot + see_image to see the page, desktop_click/desktop_type to interact. Full workflow: browser_open → desktop_screenshot → see_image (find elements) → desktop_click (click) → desktop_screenshot (verify).',
+    description: 'Open a URL in the user\'s default browser (visible). Then use desktop_screenshot + see_image to see the page, desktop_click/desktop_type to interact. Full workflow: browser_open → desktop_screenshot → see_image (find elements) → desktop_click (click) → desktop_screenshot (verify). When running inside a host browser (BrowserOS ACP), this navigates the host\'s active tab instead of opening a new OS window — pair it with browser_snapshot/browser_read.',
     parameters: {
         type: 'object',
         properties: {
@@ -506,6 +506,26 @@ export const browserOpenTool = {
         const url = String(args.url ?? '').trim();
         if (!/^https?:\/\//i.test(url))
             return { output: 'only http(s) URLs', isError: true };
+        // Under a host browser (acp-serve/BrowserOS): opening the OS default
+        // browser pops a SECOND window per call — the exact bug users see as
+        // "a new browser window on every message". Navigate the host's active
+        // tab instead; the browser_* family reads/verifies from there.
+        const attachPort = Number(process.env.HMH_BROWSER_ATTACH ?? 0);
+        if (Number.isInteger(attachPort) && attachPort > 0) {
+            try {
+                const { CdpBrowser } = await import('@hmharness/browser');
+                const c = new CdpBrowser({ port: attachPort });
+                if (await c.up()) {
+                    const tabs = (await c.tabs()).filter((t) => !t.url.startsWith('chrome-extension://'));
+                    const page = tabs.find((t) => !t.url.startsWith('about:')) ?? tabs[0];
+                    const tid = page?.targetId ?? (await c.openTab('about:blank'));
+                    await c.navigate(tid, url);
+                    const title = String(await c.evaluate(tid, 'document.title').catch(() => ''));
+                    return { output: `navigated the host browser to ${url} (title: ${title || 'loading'}) — use browser_snapshot/browser_read to see the page` };
+                }
+            }
+            catch { /* fall through to the default-browser path if attach fails */ }
+        }
         try {
             if (process.platform === 'win32') {
                 const { execFile } = await import('node:child_process');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hmharness/agent",
-  "version": "0.23.21",
+  "version": "0.23.23",
   "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.21",
-    "@hmharness/domain-harmony": "0.23.21",
-    "@hmharness/domain-ops": "0.23.21",
-    "@hmharness/evolution": "0.23.21",
-    "@hmharness/kernel": "0.23.21",
-    "@hmharness/observability": "0.23.21",
-    "@hmharness/sandbox": "0.23.21",
-    "@hmharness/lsp": "0.23.21",
-    "@hmharness/browser": "0.23.21"
+    "@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"
   },
   "files": [
     "dist"