@hmharness/agent 0.10.0 → 0.12.0

package/dist/pipeline.d.ts

@@ -1,5 +1,6 @@
 import { runLoop, type LoopResult, type ProviderConfig, type Registry, type ToolContext } from '@hmharness/kernel';
-export type PipelineStage = 'plan' | 'code' | 'test' | 'review' | 'judge';
+import type { DeviceTestOptions, DeviceTestStep } from '@hmharness/domain-harmony';
+export type PipelineStage = 'plan' | 'code' | 'test' | 'review' | 'judge' | 'device';
 /** stage labels used in runStage (repairer = the repair-loop role) */
 export type StageRole = PipelineStage | 'repairer';
 export interface StageRecord {
@@ -20,6 +21,12 @@ export interface PipelineReport {
     finalVerdict: 'PASS' | 'FAIL' | 'none';
     stages: StageRecord[];
     repairsUsed: number;
+    /** set when opts.release ran on a PASS verdict (ADR-0008) */
+    release?: {
+        projectId: string;
+        version: string;
+        checkpointId: string;
+    };
 }
 export interface PipelineOptions {
     task: string;
@@ -38,6 +45,28 @@ export interface PipelineOptions {
     signal?: AbortSignal;
     /** injectable loop (tests); default kernel runLoop */
     runLoopImpl?: typeof runLoop;
+    /** V3 device gate (ADR-0007): when set, run an on-device install/launch/
+     *  log-marker/uninstall pass after the test stage and feed the four steps
+     *  to the judge as mechanical evidence. Pure command execution - no model
+     *  turns. */
+    deviceGate?: {
+        hdc: string;
+        target?: string;
+        hap: string;
+        bundle: string;
+        ability: string;
+        expectLog: string;
+        /** injectable runner (tests); default = domain-harmony runDeviceTest */
+        runDeviceTestImpl?: (o: DeviceTestOptions) => Promise<DeviceTestStep[]>;
+    };
+    /** V3 release slice (ADR-0008): when the final verdict is PASS, bind the
+     *  work to the workspace's Project Runtime (M8): attach the run, checkpoint
+     *  the tree, and record a release pinned to that checkpoint. FAIL/budget
+     *  never release - no verdict, no version. */
+    release?: {
+        version: string;
+        notes?: string;
+    };
 }
 /** Pull the judge's verdict line out of the final text; absence = FAIL
  *  (an judge that did not follow the contract did not render a verdict). */

package/dist/pipeline.js

@@ -73,6 +73,7 @@ export async function runPipeline(opts) {
     let repairs = 0;
     let spent = 0;
     let status = 'completed';
+    let releaseTick;
     const startedAt = new Date().toISOString();
     const runStage = async (stage, attempt, directive) => {
         // maxTurns is only a soft checkpoint in the kernel loop - the HARD caps
@@ -107,6 +108,35 @@ export async function runPipeline(opts) {
         catch { /* best-effort persistence */ }
         return rec;
     };
+    /** Device gate: run the four-step on-device pass, record it as a 'device'
+     *  stage (no model turns spent), and mirror it into the repair context.
+     *  Defined BEFORE the try block - the try body calls it (TDZ otherwise). */
+    const runDeviceGate = async () => {
+        const g = opts.deviceGate;
+        const runner = g.runDeviceTestImpl ?? (await import('@hmharness/domain-harmony')).runDeviceTest;
+        let steps;
+        try {
+            steps = await runner({ hdc: g.hdc, ...(g.target ? { target: g.target } : {}), hap: g.hap, bundle: g.bundle, ability: g.ability, expectLog: g.expectLog });
+        }
+        catch (err) {
+            steps = [{ step: 'device-gate', pass: false, detail: String(err).slice(0, 300) }];
+        }
+        const allPass = steps.every((s) => s.pass);
+        const rec = {
+            stage: 'device',
+            attempt: repairs + 1,
+            verdict: allPass ? 'PASS' : 'FAIL',
+            text: steps.map((s) => `${s.pass ? 'PASS' : 'FAIL'} ${s.step}: ${s.detail}`).join('\n').slice(0, 4000),
+            turns: 0,
+            toolUses: 0,
+            reason: 'final',
+        };
+        stages.push(rec);
+        try {
+            await writeFile(join(dir, `stage-${String(stages.length).padStart(2, '0')}-device.json`), JSON.stringify(rec, null, 2) + '\n', 'utf8');
+        }
+        catch { /* best-effort */ }
+    };
     try {
         // 1. plan
         const plan = await runStage('plan', 1, DIRECTIVES.plan(opts.task, ''));
@@ -126,6 +156,10 @@ export async function runPipeline(opts) {
             status = 'budget';
             return await finish();
         }
+        // 3b. device gate (V3 slice, ADR-0007): mechanical on-device evidence,
+        // zero model turns; judge sees it in the evidence summary
+        if (opts.deviceGate)
+            await runDeviceGate();
         let review = await runStage('review', 1, DIRECTIVES.review(opts.task, ''));
         if (spent >= totalBudget) {
             status = 'budget';
@@ -141,6 +175,8 @@ export async function runPipeline(opts) {
                 break;
             }
             testOut = await runStage('test', repairs + 1, DIRECTIVES.test(opts.task, `Plan:\n${plan.text.slice(0, 1500)}\nRepair ${repairs} applied - re-verify.`));
+            if (opts.deviceGate)
+                await runDeviceGate();
             review = await runStage('review', repairs + 1, DIRECTIVES.review(opts.task, `Repair ${repairs} was applied; focus on it.`));
             if (spent >= totalBudget) {
                 status = 'budget';
@@ -148,7 +184,23 @@ export async function runPipeline(opts) {
             }
             judge = await runStage('judge', repairs + 1, DIRECTIVES.judge(opts.task, evidenceSummary(stages)));
         }
-        return await finish(judge && judge.verdict !== 'n/a' ? judge.verdict : 'FAIL');
+        const verdict = judge && judge.verdict !== 'n/a' ? judge.verdict : 'FAIL';
+        // V3 release slice: only a PASS verdict earns a version (ADR-0008)
+        if (verdict === 'PASS' && opts.release) {
+            try {
+                const P = await import("./project.js");
+                const proj = await P.projectFor(opts.home, opts.ctx.cwd);
+                await P.attachRun(opts.home, proj, pipelineId);
+                const cp = await P.checkpointProject(opts.home, proj, `pipeline ${pipelineId}`);
+                await P.releaseProject(opts.home, proj, opts.release.version, opts.release.notes ?? `pipeline ${pipelineId} VERDICT: PASS (${stages.length} stages, ${repairs} repairs)`);
+                releaseTick = { projectId: proj.projectId, version: opts.release.version, checkpointId: cp.id };
+            }
+            catch (err) {
+                // release is bookkeeping - record the failure, never fail the pipeline
+                stages.push({ stage: 'judge', attempt: 0, verdict: 'n/a', text: `release binding failed: ${String(err).slice(0, 200)}`, turns: 0, toolUses: 0, reason: 'final' });
+            }
+        }
+        return await finish(verdict);
     }
     catch (err) {
         status = 'error';
@@ -165,6 +217,7 @@ export async function runPipeline(opts) {
             finalVerdict: verdict,
             stages,
             repairsUsed: repairs,
+            ...(releaseTick ? { release: releaseTick } : {}),
         };
         try {
             await writeFile(join(dir, 'pipeline.report.json'), JSON.stringify(report, null, 2) + '\n', 'utf8');
@@ -174,6 +227,6 @@ export async function runPipeline(opts) {
     }
 }
 function evidenceSummary(stages) {
-    const relevant = stages.filter((s) => s.stage === 'test' || s.stage === 'review');
+    const relevant = stages.filter((s) => s.stage === 'test' || s.stage === 'review' || s.stage === 'device');
     return relevant.map((s) => `[${s.stage} #${s.attempt}] ${s.text.slice(0, 600)}`).join('\n\n').slice(0, 3000);
 }

package/dist/project.js

@@ -192,6 +192,13 @@ export async function checkpointProject(home, rec, label) {
     else {
         const rel = `artifacts/cp-${Date.now().toString(36)}`;
         const dest = join(projDir(home, rec.projectId), rel);
+        // the copy fallback cannot handle the workspace containing the destination
+        // (workspace == home in degenerate setups) - say so plainly instead of
+        // letting cp throw EINVAL halfway through
+        const norm = (p) => resolve(p).replace(/[\\/]+$/, '').toLowerCase();
+        if (norm(dest).startsWith(norm(rec.workspace) + '\\') || norm(dest).startsWith(norm(rec.workspace) + '/')) {
+            throw new Error(`checkpoint copy fallback requires the project workspace (${rec.workspace}) to be outside HMH_HOME (${home})`);
+        }
         await mkdir(dest, { recursive: true });
         await cp(rec.workspace, dest, { recursive: true, filter: (src) => !COPY_SKIP.has(src.split(/[\\/]/).pop() ?? '') });
         let files = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hmharness/agent",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "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,7 +15,7 @@
     "build": "tsc -p tsconfig.build.json"
   },
   "dependencies": {
-    "@hmharness/domain-harmony": "0.8.0",
+    "@hmharness/domain-harmony": "0.11.0",
     "@hmharness/domain-ops": "0.8.0",
     "@hmharness/evolution": "0.9.0",
     "@hmharness/kernel": "0.9.0",