lossless-openclaw-orchestrator 1.2.4 → 1.2.6

package/.codex-plugin/plugin.json

@@ -0,0 +1,40 @@
+{
+  "name": "lossless-openclaw-orchestrator",
+  "version": "1.2.5",
+  "description": "Index, search, and prepare local Codex sessions with LCO, including one-shot thread title aliases for easier recall.",
+  "author": {
+    "name": "100yenadmin",
+    "email": "support@martian.engineering",
+    "url": "https://github.com/100yenadmin"
+  },
+  "homepage": "https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO",
+  "repository": "https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO",
+  "license": "PolyForm-Noncommercial-1.0.0",
+  "keywords": [
+    "codex",
+    "lco",
+    "thread-search",
+    "local-index"
+  ],
+  "interface": {
+    "displayName": "Lossless Codex Orchestrator",
+    "shortDescription": "Local Codex indexing and one-shot title aliases",
+    "longDescription": "LCO keeps Codex session recall local-first by indexing public-safe metadata and adding one-shot thread title aliases after assistant stops, so agents can find threads by generated names and IDs without reading raw histories.",
+    "developerName": "100yenadmin",
+    "category": "Developer Tools",
+    "capabilities": [
+      "Interactive",
+      "Read"
+    ],
+    "websiteURL": "https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO",
+    "privacyPolicyURL": "https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/blob/main/SECURITY.md",
+    "termsOfServiceURL": "https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/blob/main/LICENSE",
+    "defaultPrompt": [
+      "Search my local Codex sessions",
+      "Find the thread for this LCO task",
+      "Summarize recent Codex work"
+    ],
+    "brandColor": "#2563EB",
+    "screenshots": []
+  }
+}

package/.codex-plugin/scripts/thread-title-finalize.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { join } from "node:path";
+
+const payload = await readStdin();
+const localCli = join(process.cwd(), "dist", "packages", "cli", "src", "index.js");
+const command = existsSync(localCli) ? process.execPath : "loo";
+const args = existsSync(localCli)
+  ? [localCli, "hook", "thread-title-finalize", "--payload-stdin"]
+  : ["hook", "thread-title-finalize", "--payload-stdin"];
+
+const result = spawnSync(command, args, {
+  input: payload,
+  encoding: "utf8",
+  stdio: ["pipe", "pipe", "pipe"]
+});
+
+if (result.stdout) process.stdout.write(result.stdout);
+if (result.stderr) process.stderr.write(result.stderr);
+if (result.error) {
+  process.stderr.write(`${result.error.message}\n`);
+  process.exit(1);
+}
+process.exit(result.status ?? 1);
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks).toString("utf8");
+}

package/README.md

@@ -1,4 +1,4 @@
-# Lossless OpenClaw Orchestrator
+# Lossless Codex Orchestrator
 
 **LCO turns local Codex sessions into searchable, bounded, approval-aware
 work objects for OpenClaw.**
@@ -23,7 +23,7 @@ safe action without rereading raw transcripts.
 | Approval-gated boundaries | Dry-run Codex actions and verify matching audit ids before any live control. |
 | OpenClaw/MCP tools | Use the same local-first recall and approval-bounded surfaces from agent workflows. |
 
-[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.2.4.md) · [1.2.3 Notes](docs/RELEASE_NOTES_1.2.3.md) · [1.2.2 Notes](docs/RELEASE_NOTES_1.2.2.md) · [1.2.1 Notes](docs/RELEASE_NOTES_1.2.1.md) · [1.2.0 Notes](docs/RELEASE_NOTES_1.2.0.md) · [1.1.4 Notes](docs/RELEASE_NOTES_1.1.4.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) · [QA Lab](docs/QA_LAB.md) · [Release Notes](docs/releases/CHANGELOG.md) · [License](LICENSE)
 
 ## Why It Matters
 
@@ -38,10 +38,13 @@ before editing files.
 
 ## What It Does
 
+LCO's wedge is approval-gated orchestration over bounded, public-safe recall: an agent can safely operate a Codex fleet, not just remember it.
+
 LCO is a local-first orchestration layer for Codex-heavy work:
 
 - indexes local Codex session stores into a local SQLite database
 - searches sessions by safe summaries, plans, finals, touched files, and refs
+- adds one-shot Codex thread title aliases for easier name/ID recall
 - describes one session without exposing the whole transcript
 - expands only the evidence an agent needs, with token-budgeted profiles
 - exposes `loo_*` tools through MCP and the OpenClaw plugin
@@ -310,6 +313,8 @@ connector URLs, or customer data into public issues or PRs. Use
   extraction, search, and expansion
 - `packages/mcp-server`: stdio MCP server exposing `loo_*` tools
 - `packages/openclaw-plugin`: OpenClaw plugin entry and manifest surface
+- `.codex-plugin/` and `hooks/`: Codex plugin manifest, Stop hook config, and
+  wrapper for local thread title aliases
 - `packages/cli`: `loo` CLI for setup, indexing, recall, smoke, eval, and
   release gates
 - `packages/adapters`: Codex transport, audit, redaction, CUA/Peekaboo
@@ -325,10 +330,10 @@ The stable public product is Codex-first local orchestration: index, search,
 describe, expand, prepared-state recall, OpenClaw/MCP tools, and
 approval-gated dry-run/control boundaries.
 
-The 1.2 prepared-state and summary-leaves lane is shipped in stable `1.2.4`.
-Current launch work is the M11 GA assurance sprint, tracked in GitHub and
-summarized in [VISION.md](VISION.md). Keep sprint and agent-operator details
-there, in [AGENTS.md](AGENTS.md), and in the packaged
+The 1.2 prepared-state and summary-leaves lane is shipped in stable `1.2.6`.
+Current launch-hardening proof is summarized in [VISION.md](VISION.md) and
+[docs/QA_LAB.md](docs/QA_LAB.md). Keep sprint and agent-operator details there,
+in [AGENTS.md](AGENTS.md), and in the packaged
 [agent skill](skills/lossless-openclaw-orchestrator/SKILL.md), not in this
 public landing page. The historical 1.2 architecture handoff remains in
 [docs/sprints/brief-lco-1.2-prepared-state-summary-leaves-2026-07-03.md](docs/sprints/brief-lco-1.2-prepared-state-summary-leaves-2026-07-03.md).
@@ -345,9 +350,9 @@ thread-level `targetCoverage` with opaque source refs, freshness, coverage, and
 reason codes such as `source_present_not_indexed` instead of hiding a miss
 behind healthy global cache counts.
 The hook sidecar CLI lives under `loo hook closeout-capture`,
-`loo hook state-prep`, and `loo hook compaction-capture --mode marker`; those
-commands write only LCO-owned derived cache and treat transcript paths as
-hash/redact-only inputs.
+`loo hook state-prep`, `loo hook compaction-capture --mode marker`, and
+`loo hook thread-title-finalize`; those commands write only LCO-owned derived
+cache and treat transcript paths as hash/redact-only inputs.
 
 ## Maintainer Proof
 
@@ -376,6 +381,7 @@ loo release preflight --claim-scope codex-read-search-expand-dry-run --evidence-
 loo release demo-status --claim-scope codex-read-search-expand-dry-run --evidence-dir /Volumes/LEXAR/Codex/lossless-openclaw-orchestrator/YYYY-MM-DD/demo --strict
 loo release status --claim-scope codex-read-search-expand-dry-run --evidence-dir /Volumes/LEXAR/Codex/lossless-openclaw-orchestrator/YYYY-MM-DD/release-status --candidate-sha <release-candidate-sha> --npm-publish-approval-evidence npm-publish-approval.json --github-release-approval-evidence github-release-approval.json --github-ci-evidence github-ci.json --codeql-evidence codeql.json --strict
 loo release general-readiness --evidence-dir /Volumes/LEXAR/Codex/lossless-openclaw-orchestrator/YYYY-MM-DD/general-readiness --fresh-npm-evidence published-package-smoke.json --agent-dogfood-evidence openclaw-tool-smoke.json --strict
+loo release ga-smoke --evidence-dir /Volumes/LEXAR/Codex/lossless-openclaw-orchestrator/YYYY-MM-DD/release-ga-smoke --package-version <version> --candidate-sha <release-candidate-sha> --strict
 ```
 
 ## Development

package/VISION.md

@@ -8,19 +8,21 @@ An OpenClaw agent can understand, search, summarize, and safely coordinate a use
 
 The stable product should feel like a local orchestration cockpit: OpenClaw can see what Codex sessions exist, what each session is working on, which plans and final messages matter, which files were touched, and which next action would be safe to dry-run or execute only after explicit approval.
 
-## Current Milestone: 1.2.0 GA Assurance And Global Launch Readiness
+## Current Milestone: M12 Real-Product QA Lab And GA Release Gate
 
-The current release-readiness lane is Milestone 11: LCO 1.2.0 GA Assurance And Global Launch Readiness. GitHub tracker [#478](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/478) and children [#479](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/479)-[#493](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/493) own implementation truth; this file owns the product and eval boundary.
+The current release-readiness lane is Milestone 12: Real-Product QA Lab And GA Release Gate. GitHub tracker [#513](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/513) and children [#514](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/514)-[#522](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/522) own implementation truth; this file owns the product and eval boundary.
 
-The stable 1.0.0, 1.1.0, 1.1.1, 1.1.2, 1.1.3, 1.1.4, 1.2.0, 1.2.1, 1.2.2, and 1.2.3 packages have shipped on npm `latest` and their GitHub Releases are published. The 1.2.4 package is the current stable patch candidate; npm `latest` and GitHub Release finalization must be proven by release evidence before any global-ready claim treats it as 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 1.1 collaboration cockpit [#309](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/309) is completed proof for read-only collaboration summaries and execute-false next steps, not the current active child-work list.
+The stable 1.0.0, 1.1.0, 1.1.1, 1.1.2, 1.1.3, 1.1.4, 1.2.0, 1.2.1, 1.2.2, 1.2.3, 1.2.4, 1.2.5, and 1.2.6 packages have shipped on npm `latest` and their GitHub Releases are published as scoped stable releases. M11 proved that 1.2.5 was installable, public-safe, and honest for its declared scope. M12 raises the bar for broad/global GA: catalog presence, unit tests, and partial gateway smoke are no longer sufficient. Every declared `loo_*` tool needs tier-appropriate product evidence, and public facade tools must be exercised through OpenClaw gateway before a GA claim can include them. The 1.2.5 baseline had 60 declared `loo_*` tools and the release gateway smoke invoked 36/60, so M12 starts by making that gap explicit and blocking full-surface GA claims until covered. 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 1.1 collaboration cockpit [#309](https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/issues/309) is completed proof for read-only collaboration summaries and execute-false next steps, not the current active child-work list.
 
 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).
 
-The core Codex recall, M9 handoff paths, Codex Autonomy Cockpit, Eva Operating Picture P0 paths, 1.1 Desktop collaboration cockpit paths, 1.2 prepared-state and summary-leaf paths, release metadata, package/gateway setup proof, docs truth, release gates, and public-safe scorecards are no longer the main product gap. The current gap is no-bug-left-behind launch assurance: prove the `1.2.4` stable candidate is published, installable from npm `@latest`, discoverable, public-safe, and honest for global users before broad rollout.
+The core Codex recall, M9 handoff paths, Codex Autonomy Cockpit, Eva Operating Picture P0 paths, 1.1 Desktop collaboration cockpit paths, 1.2 prepared-state and summary-leaf paths, release metadata, package/gateway setup proof, docs truth, release gates, and public-safe scorecards are no longer the main product gap. The current gap is real-product launch assurance: prove the published product through actual CLI, MCP, OpenClaw plugin, OpenClaw gateway, local Codex session data, and sacrificial approved runtime lanes before broad rollout.
 
 The current target is:
 
-- Execute the M11 GA assurance tracker and children using public-safe evidence under `/Volumes/LEXAR/Codex/lossless-openclaw-orchestrator/2026-07-05/m11-ga-assurance/`.
+- Execute the M12 QA Lab tracker and children using public-safe evidence under `/Volumes/LEXAR/Codex/lossless-openclaw-orchestrator/2026-07-05/m12-ga-qa-lab/`.
+- Treat `loo qa-lab tool-coverage --coverage-policy full --strict` as the first full-surface GA gate. Missing product evidence is a blocker, not a warning, unless release copy explicitly excludes that tool/workflow.
+- Integrate QA Lab run, tool coverage, judge review, adversarial review, and privacy scan into `loo release ga-smoke` before any next broad GA claim.
 - Keep the launch claim scoped to local Codex prepared-state recall, search/describe/expand, summary leaves, prepared inbox/cards, OpenClaw gateway use, and approval-gated dry-run/control boundaries.
 - Fix or defer every P0-P3 launch finding with terminal disposition before calling the release globally ready.
 - Keep the 1.2 prepared-state tracker as completed proof, not the current active child-work list. The sprint brief remains the historical architecture handoff: [docs/sprints/brief-lco-1.2-prepared-state-summary-leaves-2026-07-03.md](docs/sprints/brief-lco-1.2-prepared-state-summary-leaves-2026-07-03.md).
@@ -38,7 +40,7 @@ The current target is:
 - Keep P1 source adapters, including Notion, support-control, Company Brain, Stripe, dashboard/export, and model summarization, behind separate adapters and proof gates; P0 tools report those sources as `not_configured` instead of fabricating summaries.
 - Use the [source authority profile](docs/SOURCE_AUTHORITY_PROFILE.md) to distinguish "this source returned data" from "this source owns the current truth"; unavailable or cache-only sources must degrade claims to `unknown` or low confidence.
 
-The sprint remains Codex-first, local-first, read-only-first, and public-safe by default. It does not claim full business truth, customer readiness, Claude Code parity, remote sync, generic GUI mutation, unattended desktop control, permission bypass, or enterprise/customer-ready security. npm `latest` promotion and GitHub Release creation for 1.2.4 are release gates, not assumptions. Desktop-visible classification and fallback readiness/status are proven by #307/#308; actual Codex GUI mutation remains excluded until a future action-bound proof gate records the exact backend, target, action hash, approval, and observation.
+The sprint remains Codex-first, local-first, read-only-first, and public-safe by default. It does not claim full business truth, customer readiness, Claude Code parity, remote sync, generic GUI mutation, unattended desktop control, permission bypass, or enterprise/customer-ready security. npm `latest` promotion and GitHub Release creation for 1.2.6 are release gates, not assumptions. Desktop-visible classification and fallback readiness/status are proven by #307/#308; actual Codex GUI mutation remains excluded until a future action-bound proof gate records the exact backend, target, action hash, approval, and observation.
 
 What 1.2 should let a local OpenClaw agent do next:
 
@@ -83,6 +85,7 @@ What a local OpenClaw agent can do today:
 - Classify package and gateway readiness with `loo onboard status`, `loo openclaw dogfood`, `loo openclaw tool-smoke`, and `loo openclaw published-smoke`.
 - Follow the packaged agent skill and M9 dogfood scenario to produce a public-safe recommendation from source refs, bounded expansion, detail lookups, and dry-run audit hashes.
 - Use `loo release general-readiness --strict` to decide whether fresh npm install, clean-profile OpenClaw load, clean-profile gateway readiness, and agent dogfood evidence are enough for a stable/general release claim.
+- Use `loo release ga-smoke --strict` after the individual release reports exist to aggregate the release-status, finalization, published-smoke, OpenClaw dogfood/tool-smoke, scenario, scorecard, bundle, preflight, and privacy packets into one public-safe blocker taxonomy. It is a report aggregator only; it must not publish npm, create tags, create GitHub Releases, run live control, mutate a GUI, or read raw transcripts.
 
 ## Completed Proof: Working App Runtime
 
@@ -294,7 +297,7 @@ Release candidates follow [docs/BETA_RELEASE_RUNBOOK.md](docs/BETA_RELEASE_RUNBO
 
 ## Proof Boundary
 
-Allowed stable 1.2.4 claim:
+Allowed stable 1.2.6 claim:
 
 > Collaborate with local Codex sessions through OpenClaw using local indexing, prepared-state recall, bounded expansion, and approval-gated dry-run/control boundaries.
 

package/dist/packages/adapters/src/index.js

@@ -940,6 +940,9 @@ export function createDesktopLiveProofHarness(input = {}) {
         approvalArtifact,
         backendStatus: publicBackendStatus,
         blockers,
+        proofMarkers: {
+            noActionObserved: true
+        },
         actionsPerformed: {
             desktopGuiActionRun: false,
             screenshotCaptured: false

package/dist/packages/cli/src/cli-mcp-product-smoke.js

@@ -0,0 +1,323 @@
+import { spawn, spawnSync } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const DEFAULT_REQUIRED_TOOLS = [
+    "loo_doctor",
+    "loo_prepared_inbox",
+    "loo_describe_ref",
+    "loo_expand_query"
+];
+const DEFAULT_TIMEOUT_MS = 5_000;
+export const MAX_CLI_MCP_PRODUCT_SMOKE_TIMEOUT_MS = 10_000;
+const PRIVATE_DATA_EXCLUSIONS = [
+    "raw CLI stdout/stderr",
+    "raw MCP stdout/stderr",
+    "raw local filesystem paths",
+    "raw Codex transcripts",
+    "raw prompts or message text",
+    "SQLite DBs",
+    "JSONL transcripts",
+    "screenshots or videos",
+    "tokens, credentials, API keys, cookies",
+    "customer data"
+];
+export async function createCliMcpProductSmokeReport(options) {
+    const requiredTools = uniqueStrings(options.requiredTools?.length ? options.requiredTools : DEFAULT_REQUIRED_TOOLS);
+    const cliProbe = probeCliHelp(options.cliBin ?? "loo", options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    const toolCallName = options.toolCallName ?? "loo_doctor";
+    const mcpProbe = await probeMcpToolsListAndCall(options.mcpBin ?? "loo-mcp-server", toolCallName, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    const requiredToolsPresent = requiredTools.filter((tool) => mcpProbe.tools.includes(tool));
+    const missingRequiredTools = requiredTools.filter((tool) => !mcpProbe.tools.includes(tool));
+    const blockers = uniqueStrings([
+        ...cliProbe.blockers,
+        ...mcpProbe.blockers,
+        ...(mcpProbe.ready && missingRequiredTools.length > 0 ? ["required_mcp_tools_missing"] : [])
+    ]);
+    const setupBlockers = uniqueStrings([...cliProbe.setupBlockers, ...mcpProbe.setupBlockers]);
+    const warnings = uniqueStrings([...cliProbe.warnings, ...mcpProbe.warnings]);
+    const cliReady = cliProbe.ready;
+    const mcpReady = mcpProbe.ready;
+    const mcpToolsCallReady = mcpProbe.toolCall.ok;
+    const ok = cliReady && mcpReady && mcpToolsCallReady && missingRequiredTools.length === 0 && blockers.length === 0 && setupBlockers.length === 0;
+    const report = {
+        schema: "lco.qaLab.cliMcpProductSmoke.v1",
+        ok,
+        publicSafe: true,
+        localOnly: true,
+        dryRun: true,
+        generatedAt: options.now ?? new Date().toISOString(),
+        packageName: "lossless-openclaw-orchestrator",
+        packageVersion: options.packageVersion,
+        candidateSha: options.candidateSha ?? null,
+        cliReady,
+        mcpReady,
+        mcpToolsCallReady,
+        toolsListed: mcpProbe.tools.length,
+        toolCallProbe: mcpProbe.toolCall,
+        requiredTools,
+        requiredToolsPresent,
+        missingRequiredTools,
+        blockers,
+        setupBlockers,
+        warnings,
+        actionsPerformed: {
+            npmPublished: false,
+            githubReleaseCreated: false,
+            liveCodexControlRun: false,
+            desktopGuiActionRun: false,
+            screenshotsCaptured: false
+        },
+        privateDataExclusions: PRIVATE_DATA_EXCLUSIONS,
+        proofBoundary: "This public-safe QA Lab product smoke proves CLI --help, MCP tools/list, and MCP tools/call for one safe representative tool from the selected published/fresh-install candidate binaries. The default representative call is loo_doctor with empty arguments, so deeper tools should be covered by workflow-specific QA Lab lanes. The CLI and MCP probes run sequentially with the configured timeout applied per probe. The smoke initializes MCP with protocolVersion 2024-11-05; initialize failures are reported as package/protocol-drift defects for the candidate under test. JSON-RPC id pairing is the primary request/response binding; name-mismatch detection applies only when a non-standard server echoes result.name or result.toolName. It does not run live Codex control, mutate a desktop GUI, capture screenshots, publish npm, create a GitHub Release, store raw CLI output, or store raw MCP output.",
+        nextSafeCommands: [
+            `loo qa-lab cli-mcp-smoke --evidence-dir <dir> --package-version ${options.packageVersion} --strict`,
+            "loo --help",
+            "loo-mcp-server # MCP initialize + tools/list + tools/call"
+        ]
+    };
+    if (options.evidenceDir)
+        writeCliMcpProductSmokeReport(report, options.evidenceDir);
+    return report;
+}
+export function writeCliMcpProductSmokeReport(report, evidenceDir) {
+    mkdirSync(evidenceDir, { recursive: true });
+    const outputPath = join(evidenceDir, "cli-mcp-product-smoke.json");
+    writeFileSync(outputPath, `${JSON.stringify(report, null, 2)}\n`);
+    return outputPath;
+}
+function probeCliHelp(cliBin, timeoutMs) {
+    const result = spawnSync(cliBin, ["--help"], {
+        encoding: "utf8",
+        maxBuffer: 1024 * 1024,
+        timeout: timeoutMs
+    });
+    if (result.error) {
+        if (isMissingExecutableError(result.error)) {
+            return setupRequired("cli_binary_not_found_or_not_executable");
+        }
+        if (isTimeoutError(result.error)) {
+            return packageDefect("cli_help_timeout");
+        }
+        return packageDefect("cli_help_spawn_failed");
+    }
+    if (result.status === 0)
+        return readyProbe();
+    return packageDefect("cli_help_failed");
+}
+function probeMcpToolsListAndCall(mcpBin, toolCallName, timeoutMs) {
+    return new Promise((resolve) => {
+        let resolved = false;
+        let stdoutBuffer = "";
+        let listedTools = [];
+        let timer = null;
+        let killTimer = null;
+        const child = spawn(mcpBin, [], {
+            stdio: ["pipe", "pipe", "pipe"]
+        });
+        const terminateChild = () => {
+            if (child.exitCode !== null || child.signalCode !== null)
+                return;
+            child.kill("SIGTERM");
+            killTimer = setTimeout(() => {
+                if (child.exitCode === null && child.signalCode === null)
+                    child.kill("SIGKILL");
+            }, 250);
+            killTimer.unref?.();
+        };
+        const finish = (result) => {
+            if (resolved)
+                return;
+            resolved = true;
+            if (timer)
+                clearTimeout(timer);
+            terminateChild();
+            resolve(result);
+        };
+        timer = setTimeout(() => finish({ ...packageDefect("mcp_probe_timeout"), tools: [], toolCall: failedToolCall(toolCallName, "mcp_probe_timeout") }), timeoutMs);
+        timer.unref?.();
+        const writeMessage = (payload, failureCode) => {
+            try {
+                if (!child.stdin || child.stdin.destroyed || child.stdin.writableEnded)
+                    throw new Error("stdin closed");
+                child.stdin.write(`${JSON.stringify(payload)}\n`);
+                return true;
+            }
+            catch {
+                finish({ ...packageDefect(failureCode), tools: listedTools, toolCall: failedToolCall(toolCallName, failureCode) });
+                return false;
+            }
+        };
+        child.on("error", (error) => {
+            if (isMissingExecutableError(error)) {
+                finish({ ...setupRequired("mcp_binary_not_found_or_not_executable"), tools: [], toolCall: failedToolCall(toolCallName, "mcp_binary_not_found_or_not_executable") });
+                return;
+            }
+            finish({ ...packageDefect("mcp_spawn_failed"), tools: [], toolCall: failedToolCall(toolCallName, "mcp_spawn_failed") });
+        });
+        child.on("close", () => {
+            if (killTimer)
+                clearTimeout(killTimer);
+            if (resolved)
+                return;
+            if (listedTools.length > 0) {
+                finish({ ...packageDefect("mcp_tools_call_failed"), tools: listedTools, toolCall: failedToolCall(toolCallName, "mcp_tools_call_failed") });
+                return;
+            }
+            finish({ ...packageDefect("mcp_tools_list_failed"), tools: [], toolCall: failedToolCall(toolCallName, "mcp_tools_list_failed") });
+        });
+        child.stdout?.on("data", (chunk) => {
+            stdoutBuffer += chunk.toString("utf8");
+            const lines = stdoutBuffer.split(/\r?\n/);
+            stdoutBuffer = lines.pop() ?? "";
+            for (const line of lines) {
+                const parsed = parseJsonRpcLine(line);
+                if (!parsed)
+                    continue;
+                if (parsed.id === 1 && parsed.error) {
+                    finish({ ...packageDefect("mcp_initialize_failed"), tools: [], toolCall: failedToolCall(toolCallName, "mcp_initialize_failed") });
+                    return;
+                }
+                if (parsed.id === 1 && isRecord(parsed.result)) {
+                    if (!writeMessage({ jsonrpc: "2.0", method: "notifications/initialized", params: {} }, "mcp_initialized_notification_failed"))
+                        return;
+                    if (!writeMessage({ jsonrpc: "2.0", id: 2, method: "tools/list", params: {} }, "mcp_tools_list_write_failed"))
+                        return;
+                    continue;
+                }
+                if (parsed.id === 2 && parsed.error) {
+                    finish({ ...packageDefect("mcp_tools_list_failed"), tools: [], toolCall: failedToolCall(toolCallName, "mcp_tools_list_failed") });
+                    return;
+                }
+                if (parsed.id === 2 && isRecord(parsed.result)) {
+                    const tools = extractToolNames(parsed.result.tools);
+                    listedTools = tools;
+                    if (tools.length === 0) {
+                        finish({ ...packageDefect("mcp_no_loo_tools_listed"), tools, toolCall: failedToolCall(toolCallName, "mcp_no_loo_tools_listed") });
+                        return;
+                    }
+                    if (!tools.includes(toolCallName)) {
+                        finish({
+                            ready: true,
+                            tools,
+                            setupBlockers: [],
+                            blockers: ["mcp_tool_call_tool_missing"],
+                            warnings: [],
+                            toolCall: failedToolCall(toolCallName, "mcp_tool_call_tool_missing")
+                        });
+                        return;
+                    }
+                    if (!writeMessage({
+                        jsonrpc: "2.0",
+                        id: 3,
+                        method: "tools/call",
+                        params: { name: toolCallName, arguments: {} }
+                    }, "mcp_tools_call_write_failed"))
+                        return;
+                    continue;
+                }
+                if (parsed.id === 3 && parsed.error) {
+                    finish({
+                        ready: true,
+                        tools: listedTools,
+                        setupBlockers: [],
+                        blockers: ["mcp_tools_call_failed"],
+                        warnings: [],
+                        toolCall: failedToolCall(toolCallName, "mcp_tools_call_failed")
+                    });
+                    return;
+                }
+                if (parsed.id === 3 && isRecord(parsed.result)) {
+                    const toolCall = successfulToolCall(toolCallName, parsed.result);
+                    finish({
+                        ready: true,
+                        tools: listedTools,
+                        setupBlockers: [],
+                        blockers: toolCall.ok ? [] : [toolCall.errorCode ?? "mcp_tools_call_failed"],
+                        warnings: [],
+                        toolCall
+                    });
+                    return;
+                }
+            }
+        });
+        writeMessage({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "initialize",
+            params: {
+                protocolVersion: "2024-11-05",
+                capabilities: {},
+                clientInfo: { name: "lco-cli-mcp-product-smoke", version: "1.0.0" }
+            }
+        }, "mcp_initialize_write_failed");
+    });
+}
+function failedToolCall(toolName, errorCode) {
+    return {
+        toolName,
+        ok: false,
+        contentItemCount: 0,
+        contentKinds: [],
+        structuredContentPresent: false,
+        errorCode
+    };
+}
+function successfulToolCall(toolName, result) {
+    const content = Array.isArray(result.content) ? result.content : [];
+    const responseToolName = typeof result.toolName === "string"
+        ? result.toolName
+        : typeof result.name === "string"
+            ? result.name
+            : null;
+    const nameMatches = responseToolName === null || responseToolName === toolName;
+    return {
+        toolName,
+        ok: nameMatches,
+        contentItemCount: content.length,
+        contentKinds: uniqueStrings(content.map((item) => safeContentKind(item))).slice(0, 8),
+        structuredContentPresent: Object.prototype.hasOwnProperty.call(result, "structuredContent"),
+        errorCode: nameMatches ? null : "mcp_tools_call_name_mismatch"
+    };
+}
+function safeContentKind(item) {
+    const kind = isRecord(item) && typeof item.type === "string" ? item.type : "unknown";
+    return ["text", "image", "resource", "audio", "unknown"].includes(kind) ? kind : "unknown";
+}
+function readyProbe() {
+    return { ready: true, setupBlockers: [], blockers: [], warnings: [] };
+}
+function setupRequired(code) {
+    return { ready: false, setupBlockers: [code], blockers: [], warnings: [] };
+}
+function packageDefect(code) {
+    return { ready: false, setupBlockers: [], blockers: [code], warnings: [] };
+}
+function isMissingExecutableError(error) {
+    return error.code === "ENOENT" || error.code === "EACCES";
+}
+function isTimeoutError(error) {
+    return error.code === "ETIMEDOUT";
+}
+function parseJsonRpcLine(line) {
+    try {
+        const parsed = JSON.parse(line);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function extractToolNames(value) {
+    if (!Array.isArray(value))
+        return [];
+    return uniqueStrings(value
+        .map((item) => isRecord(item) && typeof item.name === "string" ? item.name : null)
+        .filter((name) => Boolean(name))
+        .filter((name) => /^loo_[a-z0-9_]+$/.test(name)));
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function uniqueStrings(values) {
+    return [...new Set(values)];
+}