mimetic-cli 0.1.2 → 0.1.3

package/dist/oss-meta-lab.js

@@ -89,6 +89,8 @@ export async function runOssMetaLab(options) {
     if (liveRequested && missingKeys.length === 0) {
         try {
             liveDesktops = await launchLiveDesktops(assignments, localPackage ? { localPackage } : {});
+            const completionSummary = await pollLiveDesktopCompletions(liveDesktops);
+            warnings.push(...completionSummary.warnings);
         }
         catch (error) {
             warnings.push(compactError(error));
@@ -103,10 +105,14 @@ export async function runOssMetaLab(options) {
     const liveDesktopCount = liveDesktops.filter((desktop) => desktop.url).length;
     const failedLiveDesktopCount = liveDesktops.filter((desktop) => desktop.error).length;
     const startedBootstrapCount = liveDesktops.filter((desktop) => desktop.bootstrap?.status === "started").length;
+    const terminalCompletionCount = liveDesktops.filter((desktop) => isTerminalCompletion(desktop.completion)).length;
     if (liveDesktops.length > 0) {
         warnings.push(`Launched ${liveDesktopCount}/${liveDesktops.length} live E2B desktop stream${liveDesktops.length === 1 ? "" : "s"}.`);
         if (startedBootstrapCount > 0) {
             warnings.push(`Started ${startedBootstrapCount}/${liveDesktops.length} visible bootstrap terminal${liveDesktops.length === 1 ? "" : "s"} for Codex TUI attempt and nested Mimetic setup.`);
+            if (terminalCompletionCount > 0) {
+                warnings.push(`Classified ${terminalCompletionCount}/${startedBootstrapCount} bootstrap terminal state${startedBootstrapCount === 1 ? "" : "s"} from remote public-safe evidence.`);
+            }
         }
         else {
             warnings.push("Codex TUI injection and nested Mimetic execution remain the next substrate slice behind these live desktops.");
@@ -142,6 +148,9 @@ export async function runOssMetaLab(options) {
     const artifactRoot = path.join(cwd, ".mimetic", "runs", runId);
     const bundlePath = path.join(artifactRoot, "run.json");
     const createdAt = new Date().toISOString();
+    await mkdir(artifactRoot, { recursive: true });
+    const screenshotSummary = await captureLiveDesktopScreenshots(artifactRoot, liveDesktops);
+    warnings.push(...screenshotSummary.warnings);
     const bundle = buildMetaBundle({
         assignments,
         createdAt,
@@ -152,19 +161,32 @@ export async function runOssMetaLab(options) {
         missingKeys,
         runId
     });
-    await mkdir(artifactRoot, { recursive: true });
     await writeJson(bundlePath, bundle);
     await writeJson(path.join(artifactRoot, "review.json"), bundle.review);
     await writeFile(path.join(artifactRoot, "review.md"), renderMetaReviewMarkdown(bundle), "utf8");
     await writeFile(path.join(artifactRoot, "events.ndjson"), `${bundle.events.map((event) => JSON.stringify(event)).join("\n")}\n`, "utf8");
     const observer = await renderObserver(cwd, runId, { open: options.open === true });
+    const outcome = classifyMetaLabOutcome({
+        dryRun,
+        liveDesktops,
+        liveRequested,
+        missingKeys
+    });
     return {
         schema: OSS_META_LAB_SCHEMA,
-        ok: observer.ok,
+        ok: observer.ok && outcome.ok,
         assignments,
         count,
         cwd,
         dryRun,
+        ...(observer.ok && outcome.ok
+            ? {}
+            : {
+                error: {
+                    code: "MIMETIC_META_RUN_FAILED",
+                    message: observer.ok ? outcome.reason : observer.error?.message ?? "OSS meta-lab Observer failed."
+                }
+            }),
         liveRequested,
         observer,
         repos,
@@ -173,6 +195,18 @@ export async function runOssMetaLab(options) {
         warnings: [...warnings, ...observer.warnings]
     };
 }
+export function buildOssMetaBundleFixture(args) {
+    return buildMetaBundle({
+        assignments: args.assignments,
+        createdAt: args.createdAt,
+        cwd: args.cwd,
+        dryRun: args.dryRun,
+        liveDesktops: args.lanes,
+        liveRequested: args.liveRequested,
+        missingKeys: args.missingKeys,
+        runId: args.runId
+    });
+}
 function buildMetaBundle(args) {
     const simulations = [];
     const streams = [];
@@ -189,6 +223,9 @@ function buildMetaBundle(args) {
         const prompt = buildCodexBootstrapPrompt(assignment);
         const liveDesktop = args.liveDesktops.find((desktop) => desktop.streamId === assignment.streamId);
         const status = statusForMeta(args, liveDesktop);
+        const completion = liveDesktop?.completion;
+        const screenshot = liveDesktop?.screenshot;
+        const terminalTail = terminalTailForMeta(prompt, liveDesktop);
         simulations.push({
             id: assignment.simId,
             index: assignment.index,
@@ -196,12 +233,14 @@ function buildMetaBundle(args) {
             scenarioId: assignment.scenarioId,
             status,
             streamKind: "browser",
-            mode: "ui-sim",
+            mode: "browser-sim",
             progress: progressForMeta(status, liveDesktop),
             currentStep: currentStepForMeta(args, assignment),
-            summary: liveDesktop?.bootstrap?.status === "started"
-                ? `Headed E2B desktop lane assigned to ${assignment.repo}; bootstrap terminal launched to set up Mimetic and open the nested Observer.`
-                : `Headed E2B desktop lane assigned to ${assignment.repo}; nested Codex TUI should set up Mimetic and open a nested Observer inside that desktop.`,
+            summary: completion
+                ? `Headed E2B desktop lane assigned to ${assignment.repo}; ${completion.reason}`
+                : liveDesktop?.bootstrap?.status === "started"
+                    ? `Headed E2B desktop lane assigned to ${assignment.repo}; bootstrap terminal launched to set up Mimetic and open the nested Observer.`
+                    : `Headed E2B desktop lane assigned to ${assignment.repo}; nested Codex TUI should set up Mimetic and open a nested Observer inside that desktop.`,
             streamIds: [assignment.streamId],
             startedAt: args.createdAt,
             updatedAt: args.createdAt
@@ -212,12 +251,12 @@ function buildMetaBundle(args) {
             kind: "browser",
             label: `E2B desktop - ${assignment.repo}`,
             status,
-            transport: liveDesktop?.url ? "sse" : status === "contract_proof_only" ? "snapshot" : "sse",
+            transport: screenshot ? "snapshot" : liveDesktop?.url ? "sse" : status === "contract_proof_only" ? "snapshot" : "sse",
             updatedAt: args.createdAt,
-            ...(liveDesktop?.url ? { url: liveDesktop.url } : {}),
+            ...(liveDesktop?.url && !screenshot ? { url: liveDesktop.url } : {}),
             embed: {
-                kind: liveDesktop?.url ? "iframe" : "placeholder",
-                ...(liveDesktop?.url ? { url: liveDesktop.url } : {}),
+                kind: screenshot ? "screenshot" : liveDesktop?.url ? "iframe" : "placeholder",
+                ...(liveDesktop?.url && !screenshot ? { url: liveDesktop.url } : {}),
                 title: `E2B desktop ${assignment.index}`
             },
             viewport: {
@@ -229,21 +268,26 @@ function buildMetaBundle(args) {
                 title: `Codex TUI bootstrap - ${assignment.repo}`,
                 format: "plain",
                 stdin: liveDesktop?.bootstrap ? "sent" : "planned",
-                tail: liveDesktop?.bootstrap?.tail ?? prompt
+                tail: terminalTail
             },
             ui: {
                 route: `e2b://desktop/${assignment.repo}`,
                 intent: "Watch the headed desktop where Codex clones the repo, sets up Mimetic, and opens the nested Observer.",
-                state: liveDesktop?.bootstrap?.status === "started"
-                    ? "bootstrap terminal launched"
-                    : liveDesktop?.url ? "live E2B desktop" : args.dryRun ? "contract desktop" : "headed E2B desktop"
+                ...(screenshot ? { screenshotUrl: screenshot.observerUrl } : {}),
+                state: completion
+                    ? completion.reason
+                    : liveDesktop?.bootstrap?.status === "started"
+                        ? "bootstrap terminal launched"
+                        : liveDesktop?.url ? "live E2B desktop" : args.dryRun ? "contract desktop" : "headed E2B desktop"
             },
+            ...(completion ? { completion: completionForStream(completion) } : {}),
             artifacts: [
                 { label: "run bundle", path: "run.json", kind: "bundle" },
                 { label: "review", path: "review.md", kind: "review" },
                 { label: "events", path: "events.ndjson", kind: "events" },
                 ...(liveDesktop?.bootstrap?.logPath ? [{ label: "remote bootstrap log", path: liveDesktop.bootstrap.logPath, kind: "log" }] : []),
-                ...(liveDesktop?.bootstrap?.nestedObserverPath ? [{ label: "nested observer path", path: liveDesktop.bootstrap.nestedObserverPath, kind: "observer" }] : [])
+                ...(liveDesktop?.bootstrap?.nestedObserverPath ? [{ label: "nested observer path", path: liveDesktop.bootstrap.nestedObserverPath, kind: "observer" }] : []),
+                ...(screenshot ? [{ label: "desktop screenshot", path: screenshot.path, kind: "screenshot" }] : [])
             ]
         });
         events.push({
@@ -283,6 +327,17 @@ function buildMetaBundle(args) {
                     simId: assignment.simId,
                     streamId: assignment.streamId
                 });
+                if (completion) {
+                    events.push({
+                        id: `event-${String(assignment.index).padStart(3, "0")}-bootstrap-${completion.status}`,
+                        at: completion.checkedAt,
+                        level: eventLevelForCompletion(completion.status),
+                        type: `oss-meta.bootstrap.${completion.status}`,
+                        message: `${assignment.repo}: ${completion.reason}`,
+                        simId: assignment.simId,
+                        streamId: assignment.streamId
+                    });
+                }
             }
             else if (liveDesktop.bootstrap?.status === "failed") {
                 events.push({
@@ -407,6 +462,14 @@ function buildMetaBundle(args) {
 function statusForMeta(args, liveDesktop) {
     if (args.dryRun)
         return "contract_proof_only";
+    if (liveDesktop?.completion?.status === "passed")
+        return "passed";
+    if (liveDesktop?.completion?.status === "failed")
+        return "failed";
+    if (liveDesktop?.completion?.status === "blocked")
+        return "blocked";
+    if (liveDesktop?.completion?.status === "timed_out")
+        return "timed_out";
     if (liveDesktop?.bootstrap?.status === "failed")
         return "failed";
     if (liveDesktop?.url)
@@ -420,6 +483,12 @@ function statusForMeta(args, liveDesktop) {
 function progressForMeta(status, liveDesktop) {
     if (status === "contract_proof_only")
         return 100;
+    if (status === "passed")
+        return 100;
+    if (status === "timed_out")
+        return 100;
+    if (status === "failed" && liveDesktop?.completion)
+        return 100;
     if (status === "blocked")
         return 18;
     if (status === "failed")
@@ -435,6 +504,9 @@ function currentStepForMeta(args, assignment) {
     if (args.dryRun) {
         return `Contract ready for ${assignment.repo}; no E2B desktop launched.`;
     }
+    if (liveDesktop?.completion) {
+        return liveDesktop.completion.reason;
+    }
     if (liveDesktop?.bootstrap?.status === "started") {
         return `Bootstrap terminal launched for ${assignment.repo}; Codex TUI attempt, Mimetic setup, and nested Observer run inside the desktop.`;
     }
@@ -453,10 +525,15 @@ function currentStepForMeta(args, assignment) {
     return `Ready to launch E2B desktop and inject Codex TUI for ${assignment.repo}.`;
 }
 function createMetaReview(args) {
+    const started = args.liveDesktops.filter((desktop) => desktop.bootstrap?.status === "started");
+    const terminalCompletions = args.liveDesktops.filter((desktop) => isTerminalCompletion(desktop.completion));
+    const outcome = classifyMetaLabOutcome(args);
     const gaps = [
-        args.liveDesktops.some((desktop) => desktop.bootstrap?.status === "started")
-            ? "Visible E2B bootstrap terminals are launched and run nested Mimetic setup; completion is watched in the desktop stream rather than polled back into the top-level bundle yet."
-            : "Nested Mimetic Observer evidence is represented as a lane contract until Codex TUI injection and nested Mimetic execution land.",
+        started.length > 0 && terminalCompletions.length === started.length
+            ? "OSS lane terminal states are classified from public-safe remote bootstrap evidence; this still proves nested Mimetic setup rather than target product behavior."
+            : args.liveDesktops.some((desktop) => desktop.bootstrap?.status === "started")
+                ? "Visible E2B bootstrap terminals are launched and run nested Mimetic setup; completion is watched in the desktop stream rather than polled back into the top-level bundle yet."
+                : "Nested Mimetic Observer evidence is represented as a lane contract until Codex TUI injection and nested Mimetic execution land.",
         "The top-level run does not clone, modify, commit, push, or file issues in target repos.",
         "Only public GitHub owner/repo slugs are recorded."
     ];
@@ -468,17 +545,120 @@ function createMetaReview(args) {
     }
     return {
         schema: REVIEW_SCHEMA,
-        verdict: "contract_proof_only",
-        summary: args.dryRun
-            ? "OSS meta-lab dry-run rendered the Observer-of-Observers contract without provider spend."
-            : args.liveDesktops.some((desktop) => desktop.bootstrap?.status === "started")
-                ? "OSS meta-lab launched live E2B desktop streams, injected visible bootstrap terminals, and started nested Mimetic setup inside each desktop."
-                : args.liveDesktops.some((desktop) => desktop.url)
-                    ? "OSS meta-lab launched live E2B desktop streams and rendered them in the top-level Observer."
-                    : "OSS meta-lab rendered the live headed-desktop control surface and marked the missing substrate truth in-lane.",
+        verdict: outcome.verdict,
+        summary: outcome.verdict === "fail" || outcome.verdict === "timed_out" || outcome.verdict === "blocked"
+            ? outcome.reason
+            : args.dryRun
+                ? "OSS meta-lab dry-run rendered the Observer-of-Observers contract without provider spend."
+                : terminalCompletions.length > 0
+                    ? `OSS meta-lab launched live E2B desktop streams and classified ${terminalCompletions.length}/${started.length || terminalCompletions.length} bootstrap terminal state${terminalCompletions.length === 1 ? "" : "s"} from public-safe remote evidence.`
+                    : args.liveDesktops.some((desktop) => desktop.bootstrap?.status === "started")
+                        ? "OSS meta-lab launched live E2B desktop streams, injected visible bootstrap terminals, and started nested Mimetic setup inside each desktop."
+                        : args.liveDesktops.some((desktop) => desktop.url)
+                            ? "OSS meta-lab launched live E2B desktop streams and rendered them in the top-level Observer."
+                            : "OSS meta-lab rendered the live headed-desktop control surface and marked the missing substrate truth in-lane.",
         gaps
     };
 }
+function classifyMetaLabOutcome(args) {
+    if (args.dryRun) {
+        return {
+            ok: true,
+            reason: "OSS meta-lab dry-run rendered the Observer-of-Observers contract without provider spend.",
+            verdict: "contract_proof_only"
+        };
+    }
+    if (args.liveRequested && args.missingKeys.length > 0) {
+        return {
+            ok: true,
+            reason: `Live launch is blocked until ${args.missingKeys.join(", ")} are available in environment.`,
+            verdict: "blocked"
+        };
+    }
+    const launchFailures = args.liveDesktops.filter((desktop) => desktop.error || desktop.bootstrap?.status === "failed");
+    if (launchFailures.length > 0) {
+        return {
+            ok: false,
+            reason: `OSS meta-lab failed ${launchFailures.length}/${args.liveDesktops.length} live desktop or bootstrap launch${launchFailures.length === 1 ? "" : "es"}.`,
+            verdict: "fail"
+        };
+    }
+    const failedCompletions = args.liveDesktops.filter((desktop) => desktop.completion?.status === "failed");
+    if (failedCompletions.length > 0) {
+        return {
+            ok: false,
+            reason: `OSS meta-lab classified ${failedCompletions.length}/${args.liveDesktops.length} bootstrap terminal state${failedCompletions.length === 1 ? "" : "s"} as failed from public-safe remote evidence.`,
+            verdict: "fail"
+        };
+    }
+    const timedOutCompletions = args.liveDesktops.filter((desktop) => desktop.completion?.status === "timed_out");
+    if (timedOutCompletions.length > 0) {
+        return {
+            ok: false,
+            reason: `OSS meta-lab timed out waiting for ${timedOutCompletions.length}/${args.liveDesktops.length} bootstrap completion marker${timedOutCompletions.length === 1 ? "" : "s"}.`,
+            verdict: "timed_out"
+        };
+    }
+    const blockedCompletions = args.liveDesktops.filter((desktop) => desktop.completion?.status === "blocked");
+    if (blockedCompletions.length > 0) {
+        return {
+            ok: false,
+            reason: `OSS meta-lab classified ${blockedCompletions.length}/${args.liveDesktops.length} bootstrap terminal state${blockedCompletions.length === 1 ? "" : "s"} as blocked from public-safe remote evidence.`,
+            verdict: "blocked"
+        };
+    }
+    if (args.liveDesktops.length > 0 && args.liveDesktops.every((desktop) => desktop.completion?.status === "passed")) {
+        return {
+            ok: true,
+            reason: `OSS meta-lab passed ${args.liveDesktops.length}/${args.liveDesktops.length} bootstrap terminal states from public-safe remote evidence.`,
+            verdict: "pass"
+        };
+    }
+    return {
+        ok: true,
+        reason: "OSS meta-lab rendered the live headed-desktop control surface and marked the missing substrate truth in-lane.",
+        verdict: "contract_proof_only"
+    };
+}
+function terminalTailForMeta(prompt, liveDesktop) {
+    if (!liveDesktop?.completion) {
+        return liveDesktop?.bootstrap?.tail ?? prompt;
+    }
+    const lines = [
+        `Remote bootstrap ${liveDesktop.completion.status}: ${liveDesktop.completion.reason}`,
+        `checked_at: ${liveDesktop.completion.checkedAt}`,
+        ...(liveDesktop.completion.exitCode === undefined ? [] : [`exit_code: ${liveDesktop.completion.exitCode}`]),
+        ...(liveDesktop.completion.nestedVerifyPassed === undefined ? [] : [`nested_verify_passed: ${liveDesktop.completion.nestedVerifyPassed ? "true" : "false"}`]),
+        ...(liveDesktop.completion.nestedObserverPresent === undefined ? [] : [`nested_observer_present: ${liveDesktop.completion.nestedObserverPresent ? "true" : "false"}`]),
+        "",
+        "public-safe log tail:",
+        liveDesktop.completion.logTail?.trim() || "(no log tail captured)"
+    ];
+    return lines.join("\n").trim();
+}
+function completionForStream(completion) {
+    return {
+        checkedAt: completion.checkedAt,
+        ...(completion.exitCode === undefined ? {} : { exitCode: completion.exitCode }),
+        ...(completion.logTail === undefined ? {} : { logTail: completion.logTail }),
+        ...(completion.nestedObserverPresent === undefined ? {} : { nestedObserverPresent: completion.nestedObserverPresent }),
+        ...(completion.nestedVerifyPassed === undefined ? {} : { nestedVerifyPassed: completion.nestedVerifyPassed }),
+        reason: completion.reason,
+        status: completion.status
+    };
+}
+function eventLevelForCompletion(status) {
+    if (status === "passed")
+        return "info";
+    if (status === "running")
+        return "info";
+    if (status === "blocked" || status === "timed_out")
+        return "warn";
+    return "error";
+}
+function isTerminalCompletion(completion) {
+    return completion !== undefined && completion.status !== "running";
+}
 function buildCodexBootstrapPrompt(assignment) {
     return [
         `# Mimetic OSS Meta-Lab Actor ${assignment.index}`,
@@ -568,6 +748,7 @@ async function launchLiveDesktops(assignments, options = {}) {
             });
             return {
                 bootstrap,
+                desktop,
                 repo: assignment.repo,
                 sandboxId: desktop.sandboxId,
                 simId: assignment.simId,
@@ -585,6 +766,169 @@ async function launchLiveDesktops(assignments, options = {}) {
         }
     }));
 }
+async function pollLiveDesktopCompletions(liveDesktops) {
+    const pollable = liveDesktops.filter((desktop) => desktop.desktop
+        && desktop.bootstrap?.status === "started"
+        && desktop.bootstrap.completionPath);
+    if (pollable.length === 0) {
+        return { warnings: [] };
+    }
+    const timeoutMs = readNonNegativeInt(process.env.MIMETIC_OSS_META_COMPLETION_TIMEOUT_MS, 240_000);
+    const intervalMs = readPositiveInt(process.env.MIMETIC_OSS_META_COMPLETION_INTERVAL_MS, 5_000);
+    const requestTimeoutMs = readPositiveInt(process.env.MIMETIC_E2B_REQUEST_TIMEOUT_MS, 60_000);
+    const warnings = [];
+    if (timeoutMs === 0) {
+        warnings.push("OSS meta-lab completion polling skipped because MIMETIC_OSS_META_COMPLETION_TIMEOUT_MS=0.");
+        return { warnings };
+    }
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+        await Promise.all(pollable.map(async (desktop) => {
+            if (isTerminalCompletion(desktop.completion) || !desktop.desktop || !desktop.bootstrap?.completionPath) {
+                return;
+            }
+            const completion = await readRemoteCompletion(desktop.desktop, desktop.bootstrap, requestTimeoutMs);
+            if (completion) {
+                desktop.completion = completion;
+            }
+        }));
+        if (pollable.every((desktop) => isTerminalCompletion(desktop.completion))) {
+            return { warnings };
+        }
+        await wait(Math.min(intervalMs, Math.max(0, deadline - Date.now())));
+    }
+    await Promise.all(pollable.map(async (desktop) => {
+        if (isTerminalCompletion(desktop.completion) || !desktop.desktop || !desktop.bootstrap) {
+            return;
+        }
+        desktop.completion = {
+            checkedAt: new Date().toISOString(),
+            logTail: await readRemoteLogTail(desktop.desktop, desktop.bootstrap, requestTimeoutMs),
+            reason: `Timed out waiting ${timeoutMs}ms for remote bootstrap completion marker.`,
+            status: "timed_out"
+        };
+    }));
+    warnings.push(`Timed out waiting for ${pollable.filter((desktop) => desktop.completion?.status === "timed_out").length}/${pollable.length} OSS meta-lab bootstrap completion marker${pollable.length === 1 ? "" : "s"}.`);
+    return { warnings };
+}
+async function readRemoteCompletion(desktop, bootstrap, requestTimeoutMs) {
+    if (!bootstrap.completionPath) {
+        return null;
+    }
+    const command = `if [ -f ${shellQuote(bootstrap.completionPath)} ]; then cat ${shellQuote(bootstrap.completionPath)}; else exit 3; fi`;
+    const result = await desktop.commands.run(`bash -lc ${shellQuote(command)}`, {
+        requestTimeoutMs,
+        timeoutMs: 30_000
+    }).catch(() => null);
+    if (!result || (result.exitCode && result.exitCode !== 0) || !result.stdout) {
+        return null;
+    }
+    return parseRemoteCompletion(result.stdout);
+}
+async function readRemoteLogTail(desktop, bootstrap, requestTimeoutMs) {
+    if (!bootstrap.logPath) {
+        return "";
+    }
+    const command = `tail -n 80 ${shellQuote(bootstrap.logPath)} 2>/dev/null || true`;
+    const result = await desktop.commands.run(`bash -lc ${shellQuote(command)}`, {
+        requestTimeoutMs,
+        timeoutMs: 30_000
+    }).catch(() => null);
+    return sanitizeRemoteLog(result?.stdout ?? "");
+}
+async function captureLiveDesktopScreenshots(artifactRoot, liveDesktops) {
+    const candidates = liveDesktops.filter((desktop) => desktop.desktop && desktop.url);
+    if (candidates.length === 0) {
+        return { warnings: [] };
+    }
+    const screenshotRoot = path.join(artifactRoot, "screenshots");
+    await mkdir(screenshotRoot, { recursive: true });
+    const warnings = [];
+    await Promise.all(candidates.map(async (desktop) => {
+        if (!desktop.desktop) {
+            return;
+        }
+        try {
+            const bytes = await desktop.desktop.screenshot("bytes");
+            const fileName = `${safeArtifactToken(desktop.streamId)}.png`;
+            const screenshotPath = path.join(screenshotRoot, fileName);
+            await writeFile(screenshotPath, Buffer.from(bytes));
+            desktop.screenshot = {
+                capturedAt: new Date().toISOString(),
+                observerUrl: `../screenshots/${fileName}`,
+                path: path.join("screenshots", fileName)
+            };
+        }
+        catch (error) {
+            warnings.push(`Screenshot capture failed for ${desktop.repo}: ${compactError(error)}`);
+        }
+    }));
+    const capturedCount = liveDesktops.filter((desktop) => desktop.screenshot).length;
+    if (capturedCount > 0) {
+        warnings.push(`Captured ${capturedCount}/${candidates.length} E2B desktop screenshot fallback${candidates.length === 1 ? "" : "s"}.`);
+    }
+    return { warnings };
+}
+function parseRemoteCompletion(payload) {
+    try {
+        const parsed = JSON.parse(payload);
+        const status = normalizeCompletionStatus(parsed.status);
+        if (!status) {
+            return null;
+        }
+        const nestedVerifyPassed = parsed.nestedVerifyStatus === "passed"
+            ? true
+            : parsed.nestedVerifyStatus === "failed" ? false : undefined;
+        return {
+            checkedAt: typeof parsed.completedAt === "string" ? parsed.completedAt : new Date().toISOString(),
+            ...(typeof parsed.exitCode === "number" ? { exitCode: parsed.exitCode } : {}),
+            ...(typeof parsed.logTail === "string" ? { logTail: sanitizeRemoteLog(parsed.logTail) } : {}),
+            ...(typeof parsed.nestedObserverPresent === "boolean" ? { nestedObserverPresent: parsed.nestedObserverPresent } : {}),
+            ...(nestedVerifyPassed === undefined ? {} : { nestedVerifyPassed }),
+            reason: typeof parsed.reason === "string" && parsed.reason.trim()
+                ? sanitizeRemoteLog(parsed.reason).replace(/\s+/g, " ").slice(0, 240)
+                : defaultReasonForCompletion(status),
+            status
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeCompletionStatus(value) {
+    return value === "running"
+        || value === "passed"
+        || value === "failed"
+        || value === "blocked"
+        || value === "timed_out"
+        ? value
+        : null;
+}
+function defaultReasonForCompletion(status) {
+    switch (status) {
+        case "passed":
+            return "Remote bootstrap completed successfully.";
+        case "failed":
+            return "Remote bootstrap failed.";
+        case "blocked":
+            return "Remote bootstrap is blocked.";
+        case "timed_out":
+            return "Remote bootstrap completion timed out.";
+        case "running":
+            return "Remote bootstrap is still running.";
+    }
+}
+function sanitizeRemoteLog(value) {
+    return value
+        .replace(/sk-[A-Za-z0-9_-]{12,}/g, "[redacted-openai-key]")
+        .replace(/e2b_[A-Za-z0-9_-]{12,}/g, "[redacted-e2b-key]")
+        .replace(/gh[pousr]_[A-Za-z0-9_]{12,}/g, "[redacted-github-token]")
+        .replace(/https?:\/\/[^/\s]*e2b[^)\s]+/gi, "[redacted-e2b-url]")
+        .split(/\r?\n/)
+        .slice(-80)
+        .join("\n")
+        .trim();
+}
 async function loadE2BDesktopModule() {
     try {
         return await import("@e2b/desktop");
@@ -607,6 +951,7 @@ async function startOssBootstrap(desktop, assignment, localPackage, requestTimeo
     const bootstrapPath = `${rootDir}/bootstrap.sh`;
     const launcherPath = `${rootDir}/launch-terminal.sh`;
     const logPath = `${rootDir}/bootstrap.log`;
+    const completionPath = `${rootDir}/completion.json`;
     const nestedObserverPath = `${rootDir}/repo/.mimetic/runs/nested-${token}/observer/index.html`;
     const title = `Mimetic ${assignment.index} ${assignment.repo}`;
     const baseTail = [
@@ -614,6 +959,7 @@ async function startOssBootstrap(desktop, assignment, localPackage, requestTimeo
         `sandbox: ${desktop.sandboxId}`,
         `remote package: ${localPackage ? remotePackagePath : "npm:mimetic-cli fallback"}`,
         `bootstrap: ${bootstrapPath}`,
+        `completion: ${completionPath}`,
         `log: ${logPath}`,
         `nested observer: ${nestedObserverPath}`
     ].join("\n");
@@ -631,6 +977,7 @@ async function startOssBootstrap(desktop, assignment, localPackage, requestTimeo
         }
         const bootstrapScript = buildRemoteBootstrapScript({
             assignment,
+            completionPath,
             logPath,
             nestedObserverPath,
             rootDir,
@@ -660,6 +1007,7 @@ async function startOssBootstrap(desktop, assignment, localPackage, requestTimeo
         }).catch(() => undefined);
         return {
             codexMode: "tui-attempted",
+            completionPath,
             launcherPath,
             logPath,
             mimeticPackageUploaded: Boolean(localPackage),
@@ -675,6 +1023,7 @@ async function startOssBootstrap(desktop, assignment, localPackage, requestTimeo
     catch (error) {
         return {
             codexMode: "tui-attempted",
+            completionPath,
             launcherPath,
             logPath,
             mimeticPackageUploaded: Boolean(localPackage),
@@ -698,11 +1047,65 @@ export MIMETIC_PUBLIC_SAFE=1
 ROOT_DIR=${shellQuote(args.rootDir)}
 APP_DIR="$ROOT_DIR/repo"
 LOG_PATH=${shellQuote(args.logPath)}
+COMPLETION_PATH=${shellQuote(args.completionPath)}
 NESTED_OBSERVER=${shellQuote(args.nestedObserverPath)}
 REMOTE_PACKAGE=${args.remotePackagePath ? shellQuote(args.remotePackagePath) : "''"}
 mkdir -p "$ROOT_DIR"
 touch "$LOG_PATH"
 exec > >(tee -a "$LOG_PATH") 2>&1
+NESTED_VERIFY_STATUS=not_run
+
+write_completion() {
+  local status="$1"
+  local reason="$2"
+  local exit_code="$3"
+  local nested_observer_present=false
+  if [[ -f "$NESTED_OBSERVER" ]]; then
+    nested_observer_present=true
+  fi
+
+  node - "$COMPLETION_PATH" "$LOG_PATH" "$status" "$reason" "$exit_code" "$nested_observer_present" "$NESTED_VERIFY_STATUS" <<'NODE' || true
+const fs = require("node:fs");
+const [
+  completionPath,
+  logPath,
+  status,
+  reason,
+  exitCode,
+  nestedObserverPresent,
+  nestedVerifyStatus
+] = process.argv.slice(2);
+const rawTail = fs.existsSync(logPath)
+  ? fs.readFileSync(logPath, "utf8").split(/\\r?\\n/).slice(-80).join("\\n")
+  : "";
+const redactedTail = rawTail
+  .replace(/sk-[A-Za-z0-9_-]{12,}/g, "[redacted-openai-key]")
+  .replace(/e2b_[A-Za-z0-9_-]{12,}/g, "[redacted-e2b-key]")
+  .replace(/gh[pousr]_[A-Za-z0-9_]{12,}/g, "[redacted-github-token]");
+fs.writeFileSync(completionPath, JSON.stringify({
+  schema: "mimetic.oss-meta-bootstrap-completion.v1",
+  status,
+  reason,
+  exitCode: Number(exitCode),
+  nestedObserverPresent: nestedObserverPresent === "true",
+  nestedVerifyStatus,
+  logTail: redactedTail,
+  completedAt: new Date().toISOString()
+}, null, 2) + "\\n");
+NODE
+}
+
+finish() {
+  local exit_code="$?"
+  trap - EXIT
+  if [[ "$exit_code" -eq 0 ]]; then
+    write_completion "passed" "Nested Mimetic proof completed and nested Observer path was checked." "$exit_code"
+  else
+    write_completion "failed" "Bootstrap exited before nested Mimetic proof completed." "$exit_code"
+  fi
+  exit "$exit_code"
+}
+trap finish EXIT
 
 echo "== mimetic oss meta-lab bootstrap =="
 echo "repo=${args.assignment.repo}"
@@ -778,7 +1181,12 @@ npx mimetic init --yes
 echo
 echo "== nested mimetic proof =="
 npx mimetic run --dry-run --run-id ${shellQuote(runId)}
-npx mimetic verify --run latest
+if npx mimetic verify --run latest; then
+  NESTED_VERIFY_STATUS=passed
+else
+  NESTED_VERIFY_STATUS=failed
+  exit 1
+fi
 npx mimetic watch --run latest --detach --no-open
 
 echo
@@ -894,7 +1302,9 @@ function shellQuote(value) {
 function formatLiveDesktopForResult(desktop) {
     return {
         ...(desktop.bootstrap ? { bootstrapStatus: desktop.bootstrap.status } : {}),
+        ...(desktop.completion ? { completionReason: desktop.completion.reason, completionStatus: desktop.completion.status } : {}),
         repo: desktop.repo,
+        ...(desktop.screenshot ? { screenshotPresent: true } : {}),
         ...(desktop.sandboxId ? { sandboxId: desktop.sandboxId } : {}),
         streamId: desktop.streamId,
         urlPresent: Boolean(desktop.url)
@@ -910,6 +1320,19 @@ function readPositiveInt(value, fallback) {
     const parsed = Number.parseInt(value, 10);
     return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
 }
+function readNonNegativeInt(value, fallback) {
+    if (!value || !/^\d+$/.test(value)) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : fallback;
+}
+async function wait(ms) {
+    if (ms <= 0) {
+        return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
 function compactError(error) {
     const message = error instanceof Error ? error.message : String(error);
     return message.replace(/\s+/g, " ").slice(0, 240);
@@ -921,6 +1344,10 @@ function makeMetaRunId() {
 function repoSlugToken(repo) {
     return repo.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
+function safeArtifactToken(value) {
+    const token = value.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+    return token || "artifact";
+}
 async function writeJson(filePath, value) {
     await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
 }