mtech-ai-local-runner 0.1.22 → 0.1.24

package/README.md

@@ -10,6 +10,31 @@ The package stores safe runner configuration locally and keeps OAuth refresh cre
 
 Public npm installation requires no npm account or publishing OTP. Setup requires Gateway OAuth login, and local Claude Code must already be authenticated (`claude auth status`).
 
+## 0.1.24: bounded report identity diagnostics
+
+Failed report validation records pair counts for same/different wire item IDs
+and exact text, using at most 64 transient keyed samples. Raw IDs, text, keys
+and hashes are never included in these diagnostics. Sampling does not limit
+actual task duration or messages. Multiple reports still fail; none are chosen,
+merged or deduplicated.
+
+These observations distinguish wire-output patterns, not model-generation
+identity: the inspected exec serializer assigns fresh CLI IDs. Earlier failures
+cannot be reclassified without missing identity evidence. Publication and
+foreground installation do not rerun Codex or update the daemon.
+
+## 0.1.23: separate progress from the final report
+
+Codex receives native-message instructions: optional progress is plain text and
+the structured completed/blocked report is emitted once at the end. The Runner
+derives lifecycle events; Codex is no longer asked to author normalized progress
+or checkpoint events. Claude's existing instructions are unchanged.
+
+Strict report uniqueness and final-message validation remain in force. Fake
+tests reproduce the observed multiple-report failure, but do not prove why the
+historical model emitted three reports or guarantee future model compliance.
+Publication and foreground installation do not rerun Codex or update the daemon.
+
 ## 0.1.22: completion report classification and terminal diagnostics
 
 Report validation distinguishes missing messages, zero valid reports, multiple

package/dist/src/adapters/codex/prompt-compiler.js

@@ -1,6 +1,6 @@
 import { compilePrompt as compileBrief } from "../prompt-compiler.js";
 export function compileCodexPrompt(taskPackage, label) {
-    return `${compileBrief(taskPackage, { workItemLabel: label })}\n\nUse only the ai_local job tools for repository reads, edits and approved tests. Native filesystem, commands, web, images and delegation are unavailable or denied. A denied tool is a scope boundary, never a reason to try another path. If required work cannot proceed, return the structured blocked report.`;
+    return `${compileBrief(taskPackage, { workItemLabel: label, progressReporting: "native_messages" })}\n\nUse only the ai_local job tools for repository reads, edits and approved tests. Native filesystem, commands, web, images and delegation are unavailable or denied. A denied tool is a scope boundary, never a reason to try another path. If required work cannot proceed, return the structured blocked report.`;
 }
 export const CODEX_REPORT_SCHEMA = {
     type: "object", additionalProperties: false, required: ["status", "report", "evidence", "pending_work"],

package/dist/src/adapters/codex/stream-parser.js

@@ -1,3 +1,4 @@
+import { createHmac, randomBytes } from "node:crypto";
 import { completionEnvelope, completionEvent } from "../completion-report.js";
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
@@ -22,6 +23,8 @@ export class CodexStreamParser {
     report;
     messages = 0;
     candidates = 0;
+    identityKey = randomBytes(32);
+    reportSamples = [];
     parse(line) {
         if (this.stopped)
             return [];
@@ -50,8 +53,17 @@ export class CodexStreamParser {
             if (event.type === "item.completed" && item.type === "agent_message") {
                 this.messages += 1;
                 this.report = finalReport(item.text);
-                if (["completed", "blocked"].includes(this.report.eventType))
+                if (["completed", "blocked"].includes(this.report.eventType)) {
                     this.candidates += 1;
+                    // Bounded diagnostic sample only. Neither raw IDs nor text digests
+                    // leave this parser, and sampling never changes report acceptance.
+                    if (this.reportSamples.length < 64) {
+                        const digest = (domain, value) => createHmac("sha256", this.identityKey).update(domain).update(value).digest("hex");
+                        const id = typeof item.id === "string" && item.id.length > 0 && item.id.length <= 256
+                            ? digest("id:", item.id) : undefined;
+                        this.reportSamples.push({ id, text: digest("text:", String(item.text)) });
+                    }
+                }
             }
         }
         if (event.type !== "turn.completed")
@@ -89,11 +101,41 @@ export class CodexStreamParser {
         return { eventType: "failed", summary: summaries[code], payload: { completion_report: {
                     version: "codex-completion-report-v1", code, agent_message_count: this.messages,
                     valid_report_count: this.candidates, invalid_message_count: this.messages - this.candidates,
+                    identity: this.reportIdentity(),
                 } } };
     }
+    reportIdentity() {
+        const counts = { same_item_same_text_pairs: 0, same_item_different_text_pairs: 0,
+            different_item_same_text_pairs: 0, different_item_different_text_pairs: 0 };
+        for (let i = 0; i < this.reportSamples.length; i++) {
+            const a = this.reportSamples[i];
+            if (!a.id)
+                continue;
+            for (let j = i + 1; j < this.reportSamples.length; j++) {
+                const b = this.reportSamples[j];
+                if (!b.id)
+                    continue;
+                if (a.id === b.id) {
+                    if (a.text === b.text)
+                        counts.same_item_same_text_pairs++;
+                    else
+                        counts.same_item_different_text_pairs++;
+                }
+                else if (a.text === b.text)
+                    counts.different_item_same_text_pairs++;
+                else
+                    counts.different_item_different_text_pairs++;
+            }
+        }
+        return { version: "codex-report-identity-v1", sampled_reports: this.reportSamples.length,
+            unsampled_reports: this.candidates - this.reportSamples.length,
+            missing_item_id_reports: this.reportSamples.filter(sample => !sample.id).length, ...counts };
+    }
     finish(event) {
         this.stopped = true;
         this.report = undefined;
+        this.reportSamples.length = 0;
+        this.identityKey.fill(0);
         return [event];
     }
 }

package/dist/src/adapters/completion-report.js

@@ -3,6 +3,24 @@ const MAX_EVIDENCE_ITEMS = 20;
 const MAX_EVIDENCE_CHARS = 500;
 const MAX_REPORT_ENVELOPE_CHARS = 16_000;
 const REPORT_FAILURE_CODES = ["CODEX_COMPLETION_REPORT_MISSING", "CODEX_COMPLETION_REPORT_INVALID", "CODEX_COMPLETION_REPORT_MULTIPLE", "CODEX_COMPLETION_REPORT_NOT_FINAL", "CODEX_TURN_INCOMPLETE"];
+/** Pair counts only; no item IDs, text, stable digests or arbitrary keys. */
+function reportIdentityDiagnostic(value, valid) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const d = value;
+    const keys = ["sampled_reports", "unsampled_reports", "missing_item_id_reports", "same_item_same_text_pairs",
+        "same_item_different_text_pairs", "different_item_same_text_pairs", "different_item_different_text_pairs"];
+    if (d.version !== "codex-report-identity-v1" || keys.some(key => typeof d[key] !== "number" || !Number.isSafeInteger(d[key]) || Number(d[key]) < 0))
+        return undefined;
+    const sampled = Number(d.sampled_reports), missing = Number(d.missing_item_id_reports);
+    if (sampled !== Math.min(valid, 64) || Number(d.unsampled_reports) !== valid - sampled || missing > sampled)
+        return undefined;
+    const pairs = keys.slice(3).map(key => Number(d[key]));
+    const identified = sampled - missing, expected = identified * (identified - 1) / 2;
+    if (pairs.some(count => count > expected) || pairs.reduce((sum, count) => sum + count, 0) !== expected)
+        return undefined;
+    return { version: "codex-report-identity-v1", ...Object.fromEntries(keys.map(key => [key, d[key]])) };
+}
 /** Diagnostic metadata only, never completion authority. Copy no provider text. */
 export function completionReportDiagnostic(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
@@ -18,7 +36,9 @@ export function completionReportDiagnostic(value) {
         || code === "CODEX_COMPLETION_REPORT_MULTIPLE" && valid < 2
         || code === "CODEX_COMPLETION_REPORT_NOT_FINAL" && (valid !== 1 || invalid === 0))
         return undefined;
-    return { version: "codex-completion-report-v1", code, agent_message_count: messages, valid_report_count: valid, invalid_message_count: invalid };
+    const identity = reportIdentityDiagnostic(d.identity, valid);
+    return { version: "codex-completion-report-v1", code, agent_message_count: messages, valid_report_count: valid, invalid_message_count: invalid,
+        ...(identity ? { identity } : {}) };
 }
 export const COMPLETION_REPORT_NOTICE = "Do the assigned work yourself using the available tools; do not delegate or start background work. " +
     "Do not report completed while waiting for results, tests, or another agent. " +

package/dist/src/adapters/prompt-compiler.js

@@ -4,6 +4,11 @@ const STOP_BEFORE_PUBLICATION_RULE = "Stop before publication. Never run git com
 const EVENT_SCHEMA_NOTICE = "Report progress only through the normalized event lifecycle (started, progress, file_changed, question, " +
     "test_started, test_result, budget_warning, checkpoint_ready, blocked, completed, failed). " +
     "Checkpoint your work with checkpoint_ready before stopping whenever it is safe to do so.";
+const NATIVE_PROGRESS_NOTICE = "The Runner derives lifecycle events from the native CLI stream; do not author normalized lifecycle or checkpoint events. " +
+    "If progress commentary is needed, use brief plain text, not the completion-report schema. " +
+    "Do not emit report-shaped JSON in commentary or progress messages. " +
+    "Emit the structured completion report exactly once, as your final response after all available work and checks. " +
+    "Do not repeat, preview, revise or re-emit a completed or blocked report. If blocked, stop work and emit that one final blocked report.";
 function requiredArray(value, label) {
     if (!Array.isArray(value)) {
         throw new Error(`task package is missing ${label}`);
@@ -53,7 +58,9 @@ export function compilePrompt(taskPackage, options) {
         `## Required tests\n${requiredTests.map((item) => `- ${item}`).join("\n")}`,
         `## Prohibited actions\n${prohibitedActions.map((item) => `- ${item}`).join("\n")}`,
         `## Stop-before-publication rule\n${STOP_BEFORE_PUBLICATION_RULE}`,
-        `## Event and checkpoint obligations\n${EVENT_SCHEMA_NOTICE}`,
+        options.progressReporting === "native_messages"
+            ? `## Native progress and terminal reporting\n${NATIVE_PROGRESS_NOTICE}`
+            : `## Event and checkpoint obligations\n${EVENT_SCHEMA_NOTICE}`,
         `## Final completion report\n${COMPLETION_REPORT_NOTICE}`,
     ];
     return sections.join("\n\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mtech-ai-local-runner",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "private": false,
   "license": "UNLICENSED",
   "bin": {