lossless-openclaw-orchestrator 1.1.1 → 1.1.2

package/README.md

@@ -14,7 +14,7 @@ safe action without rereading raw transcripts.
 [![License](https://img.shields.io/badge/license-PolyForm%20Noncommercial-blue)](LICENSE)
 [![PRs welcome](https://img.shields.io/badge/PRs-welcome-brightgreen)](CONTRIBUTING.md)
 
-[Setup](docs/SETUP.md) · [Contributing](CONTRIBUTING.md) · [Agent Instructions](AGENTS.md) · [Agent Skill](skills/lossless-openclaw-orchestrator/SKILL.md) · [OpenClaw Plugin](docs/OPENCLAW_PLUGIN.md) · [Security](SECURITY.md) · [Code of Conduct](CODE_OF_CONDUCT.md) · [Vision](VISION.md) · [Privacy](docs/PRIVACY.md) · [Claude Boundary](docs/CLAUDE_ADAPTER_BOUNDARY.md) · [Claim Audit](docs/CLAIM_AUDIT.md) · [Release Notes](docs/RELEASE_NOTES_1.1.1.md) · [1.0 Notes](docs/RELEASE_NOTES_1.0.0.md) · [License](LICENSE)
+[Setup](docs/SETUP.md) · [Contributing](CONTRIBUTING.md) · [Agent Instructions](AGENTS.md) · [Agent Skill](skills/lossless-openclaw-orchestrator/SKILL.md) · [OpenClaw Plugin](docs/OPENCLAW_PLUGIN.md) · [Security](SECURITY.md) · [Code of Conduct](CODE_OF_CONDUCT.md) · [Vision](VISION.md) · [Privacy](docs/PRIVACY.md) · [Claude Boundary](docs/CLAUDE_ADAPTER_BOUNDARY.md) · [Claim Audit](docs/CLAIM_AUDIT.md) · [Release Notes](docs/RELEASE_NOTES_1.1.2.md) · [1.0 Notes](docs/RELEASE_NOTES_1.0.0.md) · [License](LICENSE)
 
 ## Why It Matters
 

package/VISION.md

@@ -10,9 +10,9 @@ The stable product should feel like a local orchestration cockpit: OpenClaw can
 
 ## Current Milestone: 1.1 Desktop Collaboration Cockpit
 
-The current release lane is [#393](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/393), which publishes stable `1.1.1` on npm `latest` after the same full check, smoke, scenario, scorecard, release-status, finalization, and post-publish readiness gates used for `1.1.0`. This patch carries the same stable claim scope while adding the #380 same-connection live-control safety fix, the #385 Desktop-first agent skill wording fix, and the #382 Desktop-first daily orchestration scenario contract.
+The current release lane is [#396](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/396), which publishes stable `1.1.2` on npm `latest` after the same full check, smoke, scenario, scorecard, release-status, finalization, and post-publish readiness gates used for `1.1.1`. This patch carries the same stable claim scope while adding the #381 issue-grade public-safe live-control smoke failure report.
 
-The stable 1.0.0 and 1.1.0 packages have shipped on npm `latest` and their GitHub Releases are published. The post-GA Desktop claim-validation lane [#306](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/306) records that Desktop-visible classification and fallback readiness/status are proven, while actual Codex GUI mutation remains excluded. Desktop parity [#307](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/307) added the coherence classifier; desktop fallback [#308](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/308) added the CUA-first and Peekaboo-secondary readiness report. The active product tracker is the 1.1 collaboration cockpit [#309](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/309), with the operating loop [#16](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/16).
+The stable 1.0.0, 1.1.0, and 1.1.1 packages have shipped on npm `latest` and their GitHub Releases are published. The post-GA Desktop claim-validation lane [#306](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/306) records that Desktop-visible classification and fallback readiness/status are proven, while actual Codex GUI mutation remains excluded. Desktop parity [#307](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/307) added the coherence classifier; desktop fallback [#308](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/308) added the CUA-first and Peekaboo-secondary readiness report. The active product tracker is the 1.1 collaboration cockpit [#309](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/309), with the operating loop [#16](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/16).
 
 The Codex Autonomy Cockpit [#254](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/254) and Eva Operating Picture [#255](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/255) P0 lanes are completed beta foundation, not the current active child-work list. Completed P0 children include shared contracts [#256](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/256), source authority [#258](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/258), watcher/resume requests [#259](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/259), visible Codex map joins [#260](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/260), deterministic GitHub operating inputs [#264](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/264)/[#265](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/265), current-lane source balancing [#269](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/269), GitHub check-state fidelity [#270](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/270), cockpit card cleanup [#271](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/271), and end-to-end Eva cockpit dogfood [#272](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/272). The sprint brief remains the historical handoff for that P0 work: [docs/sprints/brief-lco-codex-autonomy-cockpit-sprint-2026-07-01.md](docs/sprints/brief-lco-codex-autonomy-cockpit-sprint-2026-07-01.md).
 
@@ -20,7 +20,7 @@ The core Codex recall, M9 handoff paths, Codex Autonomy Cockpit, Eva Operating P
 
 The current target is:
 
-- Promote npm `latest` from stable `1.1.0` to stable `1.1.1` only after #393 passes full check, smoke, scenario, scorecard, release-status, finalization, and post-publish readiness gates; keep `beta` aligned with beta trains and use `next` for future release candidates.
+- Promote npm `latest` from stable `1.1.1` to stable `1.1.2` only after #396 passes full check, smoke, scenario, scorecard, release-status, finalization, and post-publish readiness gates; keep `beta` aligned with beta trains and use `next` for future release candidates.
 - Keep README, VISION, release notes, and scorecards current so completed release gates are recorded as completed proof, not active work.
 - Treat #307/#308 as completed proof for Desktop-visible classification and fallback readiness/status, not as proof of Codex GUI mutation, prompt typing, clicking, refresh/restart automation, or unattended visible collaboration.
 - Use #309 to design the next collaboration cockpit layer from structured public-safe cards, explicit action-bound proof gates, and clear excluded-claim wording.

package/dist/packages/cli/src/live-control-smoke.js

@@ -51,11 +51,28 @@ export async function runLiveControlSmoke(options) {
     mkdirSync(options.evidenceDir, { recursive: true });
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const message = options.message ?? DEFAULT_MESSAGE;
-    await options.client.connect();
+    let targetState = {
+        threadId: options.threadId ?? null,
+        source: options.threadId ? "provided_thread" : "unknown"
+    };
+    let dryRunState = null;
+    let liveState = {
+        accepted: false,
+        approvalAuditId: null,
+        method: null,
+        completed: false,
+        status: null,
+        notificationMethods: [],
+        approvalRequestCount: 0,
+        serverRequestCount: 0
+    };
+    let failed = false;
     try {
+        await options.client.connect();
         const target = options.threadId
             ? { threadId: options.threadId, source: "provided_thread" }
             : { threadId: await startEphemeralThread(options.client, options.cwd), source: "ephemeral_thread_start" };
+        targetState = target;
         const control = createCodexControl({
             audit: options.audit,
             client: {
@@ -74,6 +91,12 @@ export async function runLiveControlSmoke(options) {
             }
         });
         const dryRun = await control.sendMessage({ threadId: target.threadId, message, dryRun: true });
+        dryRunState = {
+            approvalAuditId: dryRun.approvalAuditId,
+            paramsHash: dryRun.paramsHash,
+            messageHash: dryRun.messageHash,
+            live: false
+        };
         if (!dryRun.messageHash)
             throw new Error("dry-run did not produce a message hash");
         const live = await control.sendMessage({
@@ -82,10 +105,24 @@ export async function runLiveControlSmoke(options) {
             dryRun: false,
             approvalAuditId: dryRun.approvalAuditId
         });
+        liveState = {
+            ...liveState,
+            accepted: true,
+            approvalAuditId: live.approvalAuditId,
+            method: live.method ?? null
+        };
         const turnId = extractTurnId(live.response);
         if (!turnId)
             throw new Error("live Codex control response did not include a turn id");
         const completion = await options.client.waitForTurnCompletion({ threadId: target.threadId, turnId, timeoutMs });
+        liveState = {
+            ...liveState,
+            completed: completion.completed,
+            status: completion.status,
+            notificationMethods: summarizeMethods(completion.notificationMethods),
+            approvalRequestCount: completion.approvalRequestCount,
+            serverRequestCount: completion.serverRequestCount
+        };
         if (completion.approvalRequestCount > 0) {
             throw new Error("live Codex control smoke observed a Codex approval request; harmless smoke must not require approvals");
         }
@@ -138,8 +175,29 @@ export async function runLiveControlSmoke(options) {
         writeJson(reportPath, report);
         return report;
     }
+    catch (error) {
+        failed = true;
+        try {
+            writeFailureReport(options, {
+                error,
+                target: targetState,
+                dryRun: dryRunState,
+                live: liveState
+            });
+        }
+        catch {
+            // Best-effort evidence: never let report-writing failures mask the original smoke failure.
+        }
+        throw error;
+    }
     finally {
-        await options.client.close();
+        try {
+            await options.client.close();
+        }
+        catch (closeError) {
+            if (!failed)
+                throw closeError;
+        }
     }
 }
 export function defaultAppServerArgs() {
@@ -197,3 +255,80 @@ function summarizeMethods(methods) {
 function writeJson(path, value) {
     writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
 }
+function writeFailureReport(options, state) {
+    const blocker = classifyFailureBlocker(state.error);
+    const report = {
+        kind: "loo_live_control_smoke_failure",
+        ok: false,
+        proofReady: false,
+        generatedAt: options.now ?? new Date().toISOString(),
+        blocker,
+        command: {
+            action: "send",
+            actionClass: "codex_live_control_send"
+        },
+        target: {
+            source: state.target.source,
+            refClass: state.target.threadId ? "codex_thread" : "unknown",
+            ref: state.target.threadId ? `codex_thread:${state.target.threadId}` : null
+        },
+        dryRun: {
+            attempted: state.dryRun !== null,
+            approvalAuditId: state.dryRun?.approvalAuditId ?? null,
+            paramsHash: state.dryRun?.paramsHash ?? null,
+            messageHash: state.dryRun?.messageHash ?? null,
+            live: state.dryRun ? false : null
+        },
+        transport: {
+            class: "codex_app_server",
+            connection: "single_connection_sequence"
+        },
+        live: state.live,
+        postActionRefresh: {
+            ran: false
+        },
+        nextDiagnosticStep: nextDiagnosticStep(blocker),
+        rawPromptIncluded: false,
+        rawTranscriptIncluded: false,
+        rawSecretIncluded: false,
+        screenshotIncluded: false,
+        sqliteIncluded: false
+    };
+    writeJson(join(options.evidenceDir, "live-control-smoke-failure-report.json"), report);
+}
+function classifyFailureBlocker(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/connect|handshake|spawn|ENOENT|codex.*not found|not connected/i.test(message)) {
+        return "codex_app_server_setup_failed";
+    }
+    if (/thread(?:\/resume| not found)|control sequence step failed:\s*thread\/resume/i.test(message)) {
+        return "same_connection_resume_load_diagnostics_required";
+    }
+    if (/approval request/i.test(message))
+        return "codex_approval_request_observed";
+    if (/server request/i.test(message))
+        return "codex_server_request_observed";
+    if (/turn id/i.test(message))
+        return "live_control_turn_id_missing";
+    if (/did not complete cleanly|timeout/i.test(message))
+        return "live_control_smoke_not_completed_cleanly";
+    return "live_control_smoke_failed";
+}
+function nextDiagnosticStep(blocker) {
+    switch (blocker) {
+        case "codex_app_server_setup_failed":
+            return "Check Codex app-server command availability, stdio handshake, and local transport setup before retrying live control.";
+        case "same_connection_resume_load_diagnostics_required":
+            return "Run same-connection resume/load diagnostics for the selected thread before retrying live control.";
+        case "codex_approval_request_observed":
+            return "Inspect why the harmless smoke triggered a Codex approval request; do not treat this as approved live-control proof.";
+        case "codex_server_request_observed":
+            return "Inspect unexpected server requests from the app-server smoke; do not retry live control until the request class is understood.";
+        case "live_control_turn_id_missing":
+            return "Inspect the app-server turn/start response shape and protocol drift before retrying.";
+        case "live_control_smoke_not_completed_cleanly":
+            return "Inspect turn completion notifications, status, and timeout behavior before retrying live control.";
+        default:
+            return "Inspect the public-safe failure report and route a focused issue before retrying live control.";
+    }
+}

package/docs/RELEASE_NOTES_1.1.2.md

@@ -0,0 +1,99 @@
+# Release Notes 1.1.2
+
+`1.1.2` is a stable patch release for the post-1.1 Codex collaboration
+cockpit and OpenClaw gateway lane.
+
+It keeps the `1.1.1` stable claim scope and adds the #381 live-control smoke
+failure-evidence hardening.
+
+## What Changed
+
+- Failed `loo codex live-control-smoke` runs now write
+  `live-control-smoke-failure-report.json` before exiting non-zero.
+- The failure report is public-safe and issue-ready:
+  - blocker code
+  - command/action class
+  - target ref class
+  - dry-run/audit/hash state
+  - live acceptance state
+  - post-action refresh state
+  - next diagnostic step
+- Setup/connect failures now use the same guarded failure-report path, so
+  missing Codex app-server binaries, bad app-server args, and handshake failures
+  can produce structured public-safe evidence.
+- Failure-report write errors no longer mask the original live-control smoke
+  failure.
+- Regression coverage now proves both setup-failure reporting and original
+  error preservation.
+- Carries forward the #160 desktop proof-action release boundary:
+  `loo_desktop_proof_action` / `loo desktop proof-action` validates the
+  action-bound CUA Driver TextEdit scratch proof gate and does not prove
+  generic GUI mutation. The proof action still requires exact backend, target
+  app, target window, action hash, approval ref, permission state, scratch file
+  path, and `execute: true` before the backend can run. Generic gateway
+  invocation without exact proof args fails closed, using the same proof
+  boundary as `1.1.1`.
+  Exact gate phrase: exact backend, target app, target window, action hash, approval ref, permission state, scratch file path, and `execute: true`.
+  Exact fail-closed phrase: generic gateway invocation without exact proof args fails closed.
+  The desktop proof action keeps the same proof boundary as beta.35.
+- Carries forward strict OpenClaw gateway result handling:
+  plugin output with `output.details.ok: false` is reported as
+  `openclaw_tool_result_not_ok:<tool>` rather than successful tool proof.
+
+## Stable Claim Scope
+
+Allowed stable claim remains:
+
+> Codex-first local orchestration through OpenClaw for local Codex sessions,
+> including local indexing, search, describe, bounded expansion, dry-run control
+> envelopes, read-only collaboration cockpit/autonomy cards, read-only Desktop
+> visibility and fallback status, action-bound proof-packet validation,
+> public-safe scorecards, and installed OpenClaw gateway dogfood.
+
+This patch does not widen the live-control matrix, GUI mutation scope, Claude
+adapter scope, P1 business-adapter scope, or enterprise/customer readiness
+claim. The same excluded-claim boundaries from `1.1.1` remain in force.
+
+## Release Gate Notes
+
+- Stable issue: #396.
+- Included implementation issue: #381.
+- Parent product tracker: #309.
+- Operating-loop tracker: #16.
+- Baseline stable release: `v1.1.1`.
+- Candidate package: `lossless-openclaw-orchestrator@1.1.2`.
+- Expected git tag: `v1.1.2`.
+- Expected GitHub Release:
+  `https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/releases/tag/v1.1.2`.
+- Required pre-publish stable gates: `npm run check`, `npm pack --dry-run`,
+  strict scenario sweep, strict scorecard sweep, release preflight, release
+  bundle, release demo-status, release status, OpenClaw dogfood, and OpenClaw
+  tool-smoke for the exact stable candidate SHA.
+- Required PR gates: GitHub CI, CodeQL, current-head review threads clear, and
+  any actionable review feedback fixed before merge.
+- Required post-publish stable gates: npm `latest` view, git tag, GitHub
+  non-prerelease Release, `loo release finalization-status --expected-dist-tag
+  latest --expected-github-prerelease false --strict`, fresh npm `@latest`
+  published-smoke, and strict general-readiness before #396 closes.
+- `approved_live_control_smoke_missing` remains the expected blocker when a
+  working-app claim is attempted without approved live-control smoke evidence
+  for the exact candidate SHA.
+- Working-app status example:
+  `loo release status --claim-scope codex-working-app-proof --runtime-proof-dir <path> --approved-live-control-evidence <path> --npm-publish-approval-evidence <path> --github-release-approval-evidence <path> --candidate-sha <sha> --github-ci-evidence <path> --codeql-evidence <path> --evidence-dir <path> --strict`
+- Reduced-scope status example:
+  `loo release status --claim-scope codex-read-search-expand-dry-run --npm-publish-approval-evidence <path> --github-release-approval-evidence <path> --candidate-sha <sha> --github-ci-evidence <path> --codeql-evidence <path> --evidence-dir <path> --strict`
+- Post-publish finalization example:
+  `loo release finalization-status --evidence-dir <path> --candidate-sha <sha> --npm-publish-evidence <path> --git-tag-evidence <path> --github-release-evidence <path> --expected-dist-tag latest --expected-github-prerelease false --strict`
+
+## Explicit Non-Claims
+
+No new live Codex control smoke is run by this release.
+It does not run generic GUI mutation and does not run Codex GUI mutation.
+No automatic gateway authorization.
+No broad gateway scope approval. No prompt typing. No clicking. No arbitrary app control.
+Claude Code remains an adapter stub, not an adapter-equivalence claim.
+Bundle/status/finalization checks do not publish to npm and do not create a GitHub Release.
+No release-grade enterprise security.
+No Claude Code parity, no Notion/support-control/Stripe/Company Brain P1
+adapter proof, no cloud sync, no unattended desktop takeover, and no
+enterprise/customer-ready security is claimed.

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "lossless-openclaw-orchestrator",
   "name": "Lossless OpenClaw Orchestrator",
   "description": "Control and collaborate with local Codex sessions through OpenClaw using local indexing, bounded recall, and approval-gated controls.",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "kind": "tool",
   "tools": {
     "prefix": "loo_"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lossless-openclaw-orchestrator",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "Index, search, and control local Codex sessions through OpenClaw with approval-gated safety; Claude Code remains an experimental adapter stub.",
   "type": "module",
   "license": "PolyForm-Noncommercial-1.0.0",

package/packages/cli/src/live-control-smoke.ts

@@ -63,6 +63,53 @@ export type LiveControlSmokeReport = {
   rawPromptIncluded: false;
 };
 
+export type LiveControlSmokeFailureReport = {
+  kind: "loo_live_control_smoke_failure";
+  ok: false;
+  proofReady: false;
+  generatedAt: string;
+  blocker: string;
+  command: {
+    action: "send";
+    actionClass: "codex_live_control_send";
+  };
+  target: {
+    source: "ephemeral_thread_start" | "provided_thread" | "unknown";
+    refClass: "codex_thread" | "unknown";
+    ref: string | null;
+  };
+  dryRun: {
+    attempted: boolean;
+    approvalAuditId: string | null;
+    paramsHash: string | null;
+    messageHash: string | null;
+    live: false | null;
+  };
+  transport: {
+    class: "codex_app_server";
+    connection: "single_connection_sequence";
+  };
+  live: {
+    accepted: boolean;
+    approvalAuditId: string | null;
+    method: string | null;
+    completed: boolean;
+    status: string | null;
+    notificationMethods: string[];
+    approvalRequestCount: number;
+    serverRequestCount: number;
+  };
+  postActionRefresh: {
+    ran: false;
+  };
+  nextDiagnosticStep: string;
+  rawPromptIncluded: false;
+  rawTranscriptIncluded: false;
+  rawSecretIncluded: false;
+  screenshotIncluded: false;
+  sqliteIncluded: false;
+};
+
 export type LiveControlSmokeOptions = {
   client: LiveControlSmokeClient;
   audit: AuditStore;
@@ -133,11 +180,37 @@ export async function runLiveControlSmoke(options: LiveControlSmokeOptions): Pro
   mkdirSync(options.evidenceDir, { recursive: true });
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const message = options.message ?? DEFAULT_MESSAGE;
-  await options.client.connect();
+  let targetState: { threadId: string | null; source: "ephemeral_thread_start" | "provided_thread" | "unknown" } = {
+    threadId: options.threadId ?? null,
+    source: options.threadId ? "provided_thread" : "unknown"
+  };
+  let dryRunState: { approvalAuditId: string; paramsHash: string; messageHash?: string; live: false } | null = null;
+  let liveState: {
+    accepted: boolean;
+    approvalAuditId: string | null;
+    method: string | null;
+    completed: boolean;
+    status: string | null;
+    notificationMethods: string[];
+    approvalRequestCount: number;
+    serverRequestCount: number;
+  } = {
+    accepted: false,
+    approvalAuditId: null,
+    method: null,
+    completed: false,
+    status: null,
+    notificationMethods: [],
+    approvalRequestCount: 0,
+    serverRequestCount: 0
+  };
+  let failed = false;
   try {
+    await options.client.connect();
     const target = options.threadId
       ? { threadId: options.threadId, source: "provided_thread" as const }
       : { threadId: await startEphemeralThread(options.client, options.cwd), source: "ephemeral_thread_start" as const };
+    targetState = target;
     const control = createCodexControl({
       audit: options.audit,
       client: {
@@ -156,6 +229,12 @@ export async function runLiveControlSmoke(options: LiveControlSmokeOptions): Pro
       }
     });
     const dryRun = await control.sendMessage({ threadId: target.threadId, message, dryRun: true });
+    dryRunState = {
+      approvalAuditId: dryRun.approvalAuditId,
+      paramsHash: dryRun.paramsHash,
+      messageHash: dryRun.messageHash,
+      live: false
+    };
     if (!dryRun.messageHash) throw new Error("dry-run did not produce a message hash");
     const live = await control.sendMessage({
       threadId: target.threadId,
@@ -163,9 +242,23 @@ export async function runLiveControlSmoke(options: LiveControlSmokeOptions): Pro
       dryRun: false,
       approvalAuditId: dryRun.approvalAuditId
     });
+    liveState = {
+      ...liveState,
+      accepted: true,
+      approvalAuditId: live.approvalAuditId,
+      method: live.method ?? null
+    };
     const turnId = extractTurnId(live.response);
     if (!turnId) throw new Error("live Codex control response did not include a turn id");
     const completion = await options.client.waitForTurnCompletion({ threadId: target.threadId, turnId, timeoutMs });
+    liveState = {
+      ...liveState,
+      completed: completion.completed,
+      status: completion.status,
+      notificationMethods: summarizeMethods(completion.notificationMethods),
+      approvalRequestCount: completion.approvalRequestCount,
+      serverRequestCount: completion.serverRequestCount
+    };
     if (completion.approvalRequestCount > 0) {
       throw new Error("live Codex control smoke observed a Codex approval request; harmless smoke must not require approvals");
     }
@@ -218,8 +311,25 @@ export async function runLiveControlSmoke(options: LiveControlSmokeOptions): Pro
     writeJson(proofPath, proof);
     writeJson(reportPath, report);
     return report;
+  } catch (error) {
+    failed = true;
+    try {
+      writeFailureReport(options, {
+        error,
+        target: targetState,
+        dryRun: dryRunState,
+        live: liveState
+      });
+    } catch {
+      // Best-effort evidence: never let report-writing failures mask the original smoke failure.
+    }
+    throw error;
   } finally {
-    await options.client.close();
+    try {
+      await options.client.close();
+    } catch (closeError) {
+      if (!failed) throw closeError;
+    }
   }
 }
 
@@ -283,3 +393,96 @@ function summarizeMethods(methods: string[]): string[] {
 function writeJson(path: string, value: unknown): void {
   writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
 }
+
+function writeFailureReport(
+  options: LiveControlSmokeOptions,
+  state: {
+    error: unknown;
+    target: { threadId: string | null; source: "ephemeral_thread_start" | "provided_thread" | "unknown" };
+    dryRun: { approvalAuditId: string; paramsHash: string; messageHash?: string; live: false } | null;
+    live: {
+      accepted: boolean;
+      approvalAuditId: string | null;
+      method: string | null;
+      completed: boolean;
+      status: string | null;
+      notificationMethods: string[];
+      approvalRequestCount: number;
+      serverRequestCount: number;
+    };
+  }
+): void {
+  const blocker = classifyFailureBlocker(state.error);
+  const report: LiveControlSmokeFailureReport = {
+    kind: "loo_live_control_smoke_failure",
+    ok: false,
+    proofReady: false,
+    generatedAt: options.now ?? new Date().toISOString(),
+    blocker,
+    command: {
+      action: "send",
+      actionClass: "codex_live_control_send"
+    },
+    target: {
+      source: state.target.source,
+      refClass: state.target.threadId ? "codex_thread" : "unknown",
+      ref: state.target.threadId ? `codex_thread:${state.target.threadId}` : null
+    },
+    dryRun: {
+      attempted: state.dryRun !== null,
+      approvalAuditId: state.dryRun?.approvalAuditId ?? null,
+      paramsHash: state.dryRun?.paramsHash ?? null,
+      messageHash: state.dryRun?.messageHash ?? null,
+      live: state.dryRun ? false : null
+    },
+    transport: {
+      class: "codex_app_server",
+      connection: "single_connection_sequence"
+    },
+    live: state.live,
+    postActionRefresh: {
+      ran: false
+    },
+    nextDiagnosticStep: nextDiagnosticStep(blocker),
+    rawPromptIncluded: false,
+    rawTranscriptIncluded: false,
+    rawSecretIncluded: false,
+    screenshotIncluded: false,
+    sqliteIncluded: false
+  };
+  writeJson(join(options.evidenceDir, "live-control-smoke-failure-report.json"), report);
+}
+
+function classifyFailureBlocker(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  if (/connect|handshake|spawn|ENOENT|codex.*not found|not connected/i.test(message)) {
+    return "codex_app_server_setup_failed";
+  }
+  if (/thread(?:\/resume| not found)|control sequence step failed:\s*thread\/resume/i.test(message)) {
+    return "same_connection_resume_load_diagnostics_required";
+  }
+  if (/approval request/i.test(message)) return "codex_approval_request_observed";
+  if (/server request/i.test(message)) return "codex_server_request_observed";
+  if (/turn id/i.test(message)) return "live_control_turn_id_missing";
+  if (/did not complete cleanly|timeout/i.test(message)) return "live_control_smoke_not_completed_cleanly";
+  return "live_control_smoke_failed";
+}
+
+function nextDiagnosticStep(blocker: string): string {
+  switch (blocker) {
+    case "codex_app_server_setup_failed":
+      return "Check Codex app-server command availability, stdio handshake, and local transport setup before retrying live control.";
+    case "same_connection_resume_load_diagnostics_required":
+      return "Run same-connection resume/load diagnostics for the selected thread before retrying live control.";
+    case "codex_approval_request_observed":
+      return "Inspect why the harmless smoke triggered a Codex approval request; do not treat this as approved live-control proof.";
+    case "codex_server_request_observed":
+      return "Inspect unexpected server requests from the app-server smoke; do not retry live control until the request class is understood.";
+    case "live_control_turn_id_missing":
+      return "Inspect the app-server turn/start response shape and protocol drift before retrying.";
+    case "live_control_smoke_not_completed_cleanly":
+      return "Inspect turn completion notifications, status, and timeout behavior before retrying live control.";
+    default:
+      return "Inspect the public-safe failure report and route a focused issue before retrying live control.";
+  }
+}

package/packages/openclaw-plugin/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "lossless-openclaw-orchestrator",
   "name": "Lossless OpenClaw Orchestrator",
   "description": "Control and collaborate with local Codex sessions through OpenClaw using local indexing, bounded recall, and approval-gated controls.",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "kind": "tool",
   "tools": {
     "prefix": "loo_"