@hmharness/agent 0.23.6 → 0.23.8

package/dist/cognitive-recorder.d.ts

@@ -1,8 +1,16 @@
+/** tool name → environment id. Calibration trends group by environment, so
+ *  a browser_open step filed under "terminal" would silently pollute the
+ *  terminal curve and starve the browser one. harmony_ops_* stays terminal:
+ *  radar/brief are network reads, not device actions. */
+export declare function envForTool(toolName: string): string;
 export declare class CognitiveRunRecorder {
     private home;
-    private cwd;
-    private rec;
+    private task;
+    private sessionId;
     private store;
+    /** one recorder per environment actually touched in this run */
+    private recs;
+    private envTools;
     private open;
     private seq;
     private failures;
@@ -11,15 +19,18 @@ export declare class CognitiveRunRecorder {
      *  task step carry a prediction, feeding the calibration dimension (the
      *  §26-proven value) from 115/3043 steps toward full coverage */
     private beliefs;
-    constructor(home: string, task: string, sessionId: string, cwd: string);
+    constructor(home: string, task: string, sessionId: string, _cwd: string);
     private seedBeliefs;
     private predict;
     private learn;
+    private recFor;
+    private countEnv;
     /** loop onToolCall: open a step for this tool invocation */
     call(toolName: string, args: Record<string, unknown>): void;
     /** loop onToolResult: close the matching step (same tool, FIFO) */
     result(toolName: string, _output: string, isError: boolean): void;
-    /** task end: persist trajectory + episodic memory index entry */
+    /** task end: persist one trajectory per touched environment + an episodic
+     *  memory entry each; the primary (busiest) trajectory id is returned */
     finish(success: boolean, meta: {
         turns: number;
         toolUses: number;

package/dist/cognitive-recorder.js

@@ -3,18 +3,37 @@
  *
  * Bridges the LIVE agent loop into the Cognitive OS: every tool call becomes
  * a cognitive trajectory step (action type = tool name, reason = the loop's
- * own event context), and at task end the trajectory lands in the episodic
- * store (HMH_HOME/cognitive/trajectories/) PLUS an episodic memory index
- * entry with full provenance (source/provenance/confidence/timestamp/
- * environment/session — MEM-007). Everything here is best-effort: cognitive
- * recording must never break a task run.
+ * own event context), and at task end the trajectories land in the episodic
+ * store (HMH_HOME/cognitive/trajectories/) PLUS episodic memory index
+ * entries with full provenance (source/provenance/confidence/timestamp/
+ * environment/session — MEM-007). Steps are attributed to their REAL
+ * environment by tool name (browser_, desktop_ and harmony_ prefixed tools
+ * feed their own curves) so per-env calibration trends grow from genuine
+ * usage. Everything here is best-effort: cognitive recording must never
+ * break a task run.
  */
 import { TrajectoryStore, TrajectoryRecorder, CognitiveMemory, loadTrajectories } from '@hmharness/cognitive';
+/** tool name → environment id. Calibration trends group by environment, so
+ *  a browser_open step filed under "terminal" would silently pollute the
+ *  terminal curve and starve the browser one. harmony_ops_* stays terminal:
+ *  radar/brief are network reads, not device actions. */
+export function envForTool(toolName) {
+    if (toolName.startsWith('browser_'))
+        return 'browser';
+    if (toolName.startsWith('desktop_'))
+        return 'desktop';
+    if (toolName.startsWith('harmony_') && !toolName.startsWith('harmony_ops_'))
+        return 'harmonyos';
+    return 'terminal';
+}
 export class CognitiveRunRecorder {
     home;
-    cwd;
-    rec;
+    task;
+    sessionId;
     store;
+    /** one recorder per environment actually touched in this run */
+    recs = new Map();
+    envTools = new Map();
     open = new Map();
     seq = 0;
     failures = 0;
@@ -23,11 +42,11 @@ export class CognitiveRunRecorder {
      *  task step carry a prediction, feeding the calibration dimension (the
      *  §26-proven value) from 115/3043 steps toward full coverage */
     beliefs = new Map();
-    constructor(home, task, sessionId, cwd) {
+    constructor(home, task, sessionId, _cwd) {
         this.home = home;
-        this.cwd = cwd;
+        this.task = task;
+        this.sessionId = sessionId;
         this.store = new TrajectoryStore(home);
-        this.rec = new TrajectoryRecorder(`trj-${sessionId}-${Date.now().toString(36)}`, sessionId, { id: 'terminal', version: '1.0.0' }, { id: `goal-${sessionId}`, description: task });
         // seed beliefs from recent history (best-effort, never blocks a task)
         void this.seedBeliefs().catch(() => undefined);
     }
@@ -58,6 +77,19 @@ export class CognitiveRunRecorder {
         b.n += 1;
         this.beliefs.set(type, b);
     }
+    recFor(env) {
+        // created lazily at RESULT time: calls that never returned must not
+        // leave empty trajectories behind
+        let rec = this.recs.get(env);
+        if (!rec) {
+            rec = new TrajectoryRecorder(`trj-${this.sessionId}-${Date.now().toString(36)}-${env}`, this.sessionId, { id: env, version: '1.0.0' }, { id: `goal-${this.sessionId}`, description: this.task });
+            this.recs.set(env, rec);
+        }
+        return rec;
+    }
+    countEnv(env) {
+        this.envTools.set(env, (this.envTools.get(env) ?? 0) + 1);
+    }
     /** loop onToolCall: open a step for this tool invocation */
     call(toolName, args) {
         const key = `${toolName}#${++this.seq}`;
@@ -65,6 +97,7 @@ export class CognitiveRunRecorder {
             action: { id: key, type: toolName, args: clip(args), reason: 'agent loop tool call' },
             startedAt: Date.now(),
             prediction: this.predict(toolName),
+            env: envForTool(toolName),
         });
     }
     /** loop onToolResult: close the matching step (same tool, FIFO) */
@@ -79,7 +112,8 @@ export class CognitiveRunRecorder {
             else
                 this.successes += 1;
             this.learn(toolName, success);
-            this.rec.record({
+            this.countEnv(open.env);
+            this.recFor(open.env).record({
                 action: open.action,
                 outcome: isError ? 'failure' : 'success',
                 evidence: [],
@@ -90,36 +124,45 @@ export class CognitiveRunRecorder {
         }
         // result without a matching open call (e.g. preflight rejection): still
         // record it so denials are visible in the trajectory
-        this.rec.record({
+        const env = envForTool(toolName);
+        this.countEnv(env);
+        this.recFor(env).record({
             action: { id: `${toolName}#${++this.seq}`, type: toolName, args: {}, reason: 'tool result without recorded call' },
             outcome: isError ? 'failure' : 'success',
             evidence: [],
             prediction: this.predict(toolName),
         });
     }
-    /** task end: persist trajectory + episodic memory index entry */
+    /** task end: persist one trajectory per touched environment + an episodic
+     *  memory entry each; the primary (busiest) trajectory id is returned */
     async finish(success, meta) {
         try {
-            const traj = this.rec.finish(success);
-            // recovery heuristic: a success step that follows a failure step was
-            // already counted by TrajectoryRecorder; metrics carry it
-            const written = await this.store.append(traj);
-            if (!written.ok)
+            const written = [];
+            for (const [env, rec] of this.recs) {
+                const traj = rec.finish(success);
+                const w = await this.store.append(traj);
+                if (w.ok)
+                    written.push({ env, traj });
+            }
+            if (written.length === 0)
                 return null;
             const mem = new CognitiveMemory(this.home);
             await mem.load();
-            await mem.write({
-                layer: 'episodic',
-                content: `${success ? 'OK' : 'FAIL'} ${meta.toolUses} tools/${meta.turns} turns: ${meta.task.slice(0, 120)}`,
-                payload: { trajectoryId: traj.id, tools: meta.toolUses, turns: meta.turns, successes: this.successes, failures: this.failures },
-                source: 'agent-run',
-                provenance: `trajectory:${traj.id}`,
-                confidence: success ? 0.9 : 0.6,
-                environment: 'terminal',
-                session: traj.sessionId,
-                tags: ['run', success ? 'ok' : 'fail'],
-            });
-            return { trajectoryId: traj.id };
+            for (const { traj } of written) {
+                await mem.write({
+                    layer: 'episodic',
+                    content: `${success ? 'OK' : 'FAIL'} ${traj.environment.id}:${this.envTools.get(traj.environment.id) ?? traj.metrics.actions} tools/${meta.turns} turns: ${meta.task.slice(0, 120)}`,
+                    payload: { trajectoryId: traj.id, tools: this.envTools.get(traj.environment.id) ?? traj.metrics.actions, turns: meta.turns, successes: this.successes, failures: this.failures },
+                    source: 'agent-run',
+                    provenance: `trajectory:${traj.id}`,
+                    confidence: success ? 0.9 : 0.6,
+                    environment: traj.environment.id,
+                    session: traj.sessionId,
+                    tags: ['run', success ? 'ok' : 'fail', traj.environment.id],
+                });
+            }
+            const primary = [...written].sort((a, b) => b.traj.metrics.actions - a.traj.metrics.actions)[0];
+            return { trajectoryId: primary.traj.id };
         }
         catch {
             return null; // cognitive recording is best-effort, never fatal

package/package.json

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