@isomorph.ai/cli 0.4.2 → 0.5.1

package/dist/packages/harbour-cli/src/deploy.js

@@ -1,29 +1,26 @@
-import { homedir } from "node:os";
-import { basename, dirname, parse, resolve } from "node:path";
+import { basename, dirname, resolve } from "node:path";
 import { readFile, mkdir, rename, writeFile } from "node:fs/promises";
-import { scanWorkspace } from "../../../src/analyzer.js";
 import { createSourceManifest } from "../../../src/source-intake.js";
-import { structured } from "./remote-mcp-client.js";
 import { archiveForManifest, putMultipart } from "./upload.js";
 import { CliError } from "./output.js";
-import { confirmAudience, confirmProfile, follow, pickSourceFailure, fetchStatus, outcomeFor } from "./operations.js";
+import { continueCommand, follow, outcomeFor, pickSourceFailure, recordedRefusal, runningLine, statusFetch, summarize } from "./operations.js";
 import { CLI_VERSION } from "./version.js";
-import { isProhibitedSecretPath } from "../../../src/secret-paths.js";
-import { assertDeployReady, ensureLinkedApp } from "./integrations.js";
-import { describeSourceChange, readAppProfile, readKitLock, recordKitAppId, sourceDigest } from "./kit.js";
+import { assertSafeAppRoot, readAppTree } from "./package.js";
+import { deployBlocked, ensureLinkedApp } from "./integrations.js";
+import { describeSourceChange, kitPaths, readAppProfile, readDeclaration, readKitLock, sourceDigest } from "./kit.js";
 import { CHECKS_FAILED_HINT, checksFailedMessage, FLOW_CHECK, readReport, runChecks } from "./check.js";
 import { runCommand } from "./local-runtime.js";
 import { EMBEDDED_KIT_BUNDLE } from "./kit-bundle.js";
 /**
- * The save attestation governance records (`isomorph.stage-approval/1.0`). The
- * CLI is run by an agent, so no terminal prompt stands between the command and
- * this reply: the person's confirmation is the `.isomorph/app.json` review the
- * agent shows them before running `deploy`, and the wire schema is unchanged.
+ * The manifest built here is local: the server sees the package's digest and
+ * its file list, and opens (or resumes) the operation from those. The operation
+ * id in this manifest is therefore a fixed label, never sent.
  */
-export const SAVE_APPROVAL = "Approved.";
-export async function deploy(rootArg, client, output, tenantId, options = {}) {
-    const deployment = await runDeploy(rootArg, client, output, tenantId, options);
-    await reportSession(rootArg, deployment.operationRef, options);
+const LOCAL_MANIFEST_OPERATION = "local";
+/** Deploys the private preview: one REST route to open the operation, one to hand over the package, then the status route until it settles. */
+export async function deploy(rootArg, governance, output, tenantId, options = {}) {
+    const deployment = await runDeploy(rootArg, governance, output, tenantId, options);
+    await reportSession(rootArg, governance, deployment.operationRef, options);
     return deployment;
 }
 /**
@@ -34,25 +31,23 @@ export async function deploy(rootArg, client, output, tenantId, options = {}) {
  * outage, a missing Atlas token, or a runtime too old to have the feedback route
  * must never fail, delay or alter a deployment the builder already asked for.
  */
-async function reportSession(rootArg, operationRef, options) {
+async function reportSession(rootArg, governance, operationRef, options) {
     const notes = options.sessionNotes?.trim();
-    if (!notes || !options.integrations)
+    if (!notes)
         return;
     try {
-        const appId = options.appId ?? (await readKitLock(resolve(rootArg)))?.appId;
+        const appId = (await readKitLock(resolve(rootArg)))?.appId;
         if (!appId)
             return;
-        await options.integrations.governance.submitFeedback(appId, {
-            operationRef, cliVersion: CLI_VERSION, kitBundleVersion: options.integrations.bundle.kitVersion, notes
-        });
+        await governance.submitFeedback(appId, { operationRef, cliVersion: CLI_VERSION, kitBundleVersion: (options.bundle ?? EMBEDDED_KIT_BUNDLE).kitVersion, notes });
     }
     catch { /* never surfaced: the deployment is what the builder asked for. */ }
 }
-async function runDeploy(rootArg, client, output, tenantId, options = {}) {
+async function runDeploy(rootArg, governance, output, tenantId, options) {
     const root = resolve(rootArg);
+    const bundle = options.bundle ?? EMBEDDED_KIT_BUNDLE;
     output(`Isomorph is checking ${basename(root)}.`);
-    if (root === parse(root).root || root === resolve(homedir()))
-        throw new CliError("PREFLIGHT_APP_ROOT", "The selected app boundary is unsafe.");
+    assertSafeAppRoot(root);
     // Only a kit app deploys from here: the checks, the gate and the profile all
     // live in `.isomorph/`. Anything else deploys from the console.
     if (!(await readKitLock(root)))
@@ -63,63 +58,18 @@ async function runDeploy(rootArg, client, output, tenantId, options = {}) {
     for (const line of describeProfile(profile))
         output(line);
     // Refused here, in the first second: a deploy with no description used to run
-    // the whole gate and open an operation before `confirmProfile` refused it
-    // (live, 2026-09-16), and the operation it left behind then blocked the
-    // corrected tree as "changed before its upload finished".
+    // the whole gate and open an operation before the profile was refused (live,
+    // 2026-09-16). The deploy route records all three values, so it refuses one
+    // that is blank too; this only says so before the checks spend a minute.
     if (!profile.name.trim() || !profile.description.trim())
         throw new CliError("PROFILE_INCOMPLETE", "The app needs a name and a description in .isomorph/app.json before it can deploy.", undefined, "Edit `name` and `description` in .isomorph/app.json (show them to the person first), then run this again.");
-    let pending = await readPending(root, tenantId, client.endpoint);
-    let prior;
-    if (pending) {
-        try {
-            prior = await fetchStatus(client, pending.operationRef);
-        }
-        catch (error) {
-            if (error instanceof CliError)
-                throw withOperation(error, pending.operationRef);
-            throw new CliError("OPERATION_STATUS_UNAVAILABLE", "Isomorph could not read the existing operation. Continue it when the connection recovers; do not start another deployment.", pending.operationRef);
-        }
-        if (prior.operation?.stage === "failed" && pending.sourceDigest === (await sourceDigest(root)).digest)
-            throw intakeRejection(prior, pending.operationRef);
-        if (operationFinished(prior) && pending.sourceDigest !== (await sourceDigest(root)).digest)
-            pending = undefined;
-    }
-    else {
-        const appId = options.appId ?? (await readKitLock(root))?.appId;
-        if (appId) {
-            await client.initialize();
-            const recovered = structured(await client.call("isomorph_get_operation_status", { appId }));
-            if (!recovered || !Object.hasOwn(recovered, "operation"))
-                throw new CliError("RECOVERY_UNAVAILABLE", "This company needs Isomorph's deployment recovery update before shipping. No new deployment was started.");
-            if (recovered.operation?.operationId && !operationFinished(recovered)) {
-                prior = recovered;
-                pending = { tenantId, endpoint: client.endpoint, operationRef: recovered.operation.operationId, sourceDigest: (await sourceDigest(root)).digest, uploaded: Boolean(recovered.sourceSave || recovered.deployment || recovered.waiting || recovered.operation.stage === "awaiting-approval"), graph: await scanWorkspace(root, { sourceBoundary: "root" }), appId };
-                await writePending(root, pending);
-            }
-        }
-    }
-    if (pending && (prior?.deployment || prior?.production || prior?.waiting || operationFinished(prior))) {
-        output("Isomorph is continuing the existing operation; no new deployment was started.");
-        return finishDeployment(client, pending.operationRef, output, options);
-    }
-    if (pending && prior?.sourceSave)
-        pending.uploaded = true;
-    // A record whose upload never finished pins nothing: nothing of the old tree
-    // reached Isomorph, so the changed tree is simply what this deploy carries.
-    // Only an upload already in progress (parts sent, completion pending) must
-    // see the bytes it started with.
-    if (pending && !pending.uploaded && pending.sourceDigest !== (await sourceDigest(root)).digest) {
-        if (pending.uploadCompletion)
-            throw new CliError("UPLOAD_SOURCE_CHANGED", "The app changed while its upload was in progress. Restore the submitted files to finish it, or wait for it to expire and deploy again.", pending.operationRef);
-        output("The app changed since the previous attempt started; deploying the current code on the same operation.");
-        pending = { ...pending, sourceDigest: (await sourceDigest(root)).digest, graph: await scanWorkspace(root, { sourceBoundary: "root" }) };
-        await writePending(root, pending);
-    }
+    const { declaration, errors } = await readDeclaration(root);
+    if (errors.length && !errors[0].startsWith(".isomorph/integrations.json is missing"))
+        throw new CliError("DECLARATION_INVALID", `.isomorph/integrations.json is invalid: ${errors[0]}`);
     // Link first: the app's identity lands in `.isomorph/kit.lock.json`, which is
     // one of the deployable files, so a report pinned after the link stays fresh
-    // through the pre-flight and a refusal there does not cost a second gate run.
-    if (!pending?.uploaded && options.integrations)
-        await ensureLinkedApp(root, options.integrations.governance, tenantId, options.integrations.bundle);
+    // through the checks and the package is built from the linked tree.
+    const appId = await ensureLinkedApp(root, governance, tenantId, bundle);
     // The app's own checks are the cheapest gate Isomorph has and the most
     // expensive one to discover in the cloud. Measured: a builder shipped without
     // running `isomorph check`, the retained checks no longer matched the code,
@@ -127,133 +77,95 @@ async function runDeploy(rootArg, client, output, tenantId, options = {}) {
     // discovery — for a mismatch `isomorph check` names locally in seconds. A
     // report that passed for these exact bytes is trusted as it stands; anything
     // else runs the checks here, once, before the tree is read into memory and
-    // long before any grant lookup, operation or upload. The gate writes into
-    // `.isomorph/` as it runs, so the tree is scanned only after it.
-    if (!pending?.uploaded)
-        await ensureChecksPassed(root, output, options);
-    const graph = pending?.graph ?? await scanWorkspace(root, { sourceBoundary: "root" });
-    if (!graph.deploymentScope.includedFiles.length)
-        throw new CliError("PREFLIGHT_EMPTY", "The selected app boundary contains no eligible files.");
-    if (graph.deploymentScope.includedFiles.some(isProhibitedSecretPath))
-        throw new CliError("PREFLIGHT_SECRET_PATH", "The selected app boundary contains a prohibited secret file.");
-    const files = pending?.uploaded ? [] : await Promise.all(graph.deploymentScope.includedFiles.map(async (path) => ({ path, content: new Uint8Array(await readFile(resolve(root, path))) })));
-    output(`Isomorph found ${graph.deploymentScope.includedFiles.length} app files.`);
-    // A declared connection IT has not approved, a company whose AI setup is not
-    // ready for an app that calls it, or a CLI the platform no longer accepts would
-    // only park the deployment after the save: ask governance once, here, before
-    // any operation exists, and refuse with every blocker at once.
-    const kitAppId = pending?.appId ?? (options.integrations ? await assertDeployReady(root, options.integrations.governance, tenantId, options.integrations.bundle, "preview", output, await appCallsAi(root)) : options.appId);
-    // A `CliError` is Isomorph's own answer (`AUTH_REQUIRED` after two 401s, a
-    // JSON-RPC refusal) and reaches the builder as it is; only a plain Error from
-    // the transport — Isomorph out of reach — is "not started". Reporting a
-    // refused sign-in as unreachable sent an agent down a worse path (2026-09-14).
-    try {
-        await client.initialize();
-    }
-    catch (error) {
-        if (error instanceof CliError)
-            throw error;
-        throw new CliError("NOT_STARTED", "Isomorph could not be reached before the operation started.");
-    }
-    let start;
-    const linked = kitAppId ? { appId: kitAppId } : {};
-    // TODO(kit-band-a): every call below sends `surface: "codex"`. `src/mcp.ts` validates `surface`
-    // against its SURFACES enum (codex, claude_code, lovable, replit, v0, other), which has no "cli"
-    // member yet; send "cli" once the server accepts it.
+    // long before any operation or upload. The gate writes into `.isomorph/` as
+    // it runs, so the tree is scanned only after it.
+    await ensureChecksPassed(root, output, options);
+    const { graph, files } = await readAppTree(root);
+    output(`Isomorph found ${files.length} app files.`);
+    // The package: built once, from the bytes read above; `archiveForManifest`
+    // re-reads every file and compares its sha256, so a tree that moved under us
+    // is refused here rather than uploaded. Its digest is the operation's
+    // identity on the server — the same package resumes the same operation.
+    const manifest = await createSourceManifest({ tenantId, appId, operationId: LOCAL_MANIFEST_OPERATION, graphDigest: graph.graphDigest, files });
+    const archive = await archiveForManifest(root, manifest);
+    const note = await readDeployNote(root, tenantId);
+    if (note?.sha256 === archive.digest)
+        output(`Isomorph is continuing operation ${note.operationRef}; no new deployment was started.`);
+    // One call opens the operation — or resumes it — and runs the deploy
+    // pre-flight first: a declared connection IT has not approved, a company
+    // whose AI setup is not ready for an app that calls it, or a CLI the platform
+    // no longer accepts would only park the deployment after the save, so
+    // governance refuses here, with every blocker at once, before any operation
+    // exists. The reviewed profile rides on the same call.
+    const body = {
+        environment: "preview",
+        app: { name: profile.name, description: profile.description, audience: profile.audience },
+        package: { sha256: archive.digest, bytes: archive.body.byteLength, manifest: { schema: "isomorph.source-package-manifest/1.0", files: manifest.files.map(file => ({ path: file.path, size: file.bytes, sha256: file.sha256 })) } },
+        graph, cliVersion: CLI_VERSION, kitBundleVersion: bundle.kitVersion, declaration, callsAi: await appCallsAi(root)
+    };
+    let opened;
     try {
-        start = pending ? { operation: { operationId: pending.operationRef } } : structured(await client.call("isomorph_start_productionization", { appPath: basename(root), appName: basename(root), surface: "codex", ...linked }));
+        opened = await governance.startDeployment(appId, body);
     }
     catch (error) {
-        if (error instanceof CliError)
-            throw error;
-        throw new CliError("START_UNCONFIRMED", "Isomorph did not confirm the start response. Run deploy again to recover the app operation before starting another deployment.");
+        if (error instanceof CliError && error.code === "DEPLOY_BLOCKED")
+            throw deployBlocked(error.details?.blockers, "preview", output);
+        // An older platform has no deployment route: say so rather than "HTTP_404", and that nothing was started.
+        if (error instanceof CliError && error.code === "HTTP_404")
+            throw new CliError("DEPLOY_ROUTE_UNAVAILABLE", "This company's Isomorph does not have the kit deployment route yet. No deployment was started.", undefined, "Ask your Isomorph administrator to update the platform.", undefined, { layer: "governance" });
+        if (error instanceof CliError && error.code === "DEPLOY_IN_FLIGHT") {
+            const inFlight = typeof error.details?.operationRef === "string" ? error.details.operationRef : undefined;
+            throw new CliError(error.code, error.message, inFlight, inFlight ? `Follow it with \`${continueCommand(inFlight)}\`; deploy again once it has settled.` : undefined, undefined, { layer: "governance" });
+        }
+        throw error;
     }
-    const operationRef = start.operation?.operationId;
-    if (!operationRef)
-        throw new CliError("START_UNCONFIRMED", "Isomorph did not return the operation reference. Recover the app operation before starting another deployment.");
-    pending ??= { tenantId, endpoint: client.endpoint, operationRef, sourceDigest: (await sourceDigest(root)).digest, uploaded: false, graph, ...(kitAppId ? { appId: kitAppId } : {}) };
-    await writePending(root, pending);
-    output(`Isomorph operation saved. Continue with isomorph status --operation ${operationRef} --wait --json.`);
+    const { operationRef } = opened;
+    await writeDeployNote(root, { schema: "isomorph.deploy-note/1.0", tenantId, operationRef, sha256: archive.digest });
+    if (opened.resumed && note?.sha256 !== archive.digest)
+        output(`Isomorph is continuing operation ${operationRef}; no new deployment was started.`);
+    output(`Isomorph operation saved. Continue with ${continueCommand(operationRef)}.`);
+    const fetch = statusFetch(governance, appId, operationRef);
     try {
-        let appId = pending.appId;
-        if (!pending.uploaded && !pending.uploadCompletion) {
-            const submitted = structured(await client.call("isomorph_submit_application_graph", { operationId: operationRef, surface: "codex", graph, ...linked }));
-            if (submitted.nextTool && !matchesTool(submitted.nextTool, "isomorph_prepare_source_upload"))
-                throw new CliError("UNSUPPORTED_NEXT_STEP", "Isomorph returned an unsupported next step.", operationRef);
-            appId = typeof submitted.appId === "string" ? submitted.appId.trim() : "";
-            if (!appId)
-                throw new CliError("APP_IDENTITY_MISSING", "Isomorph did not return the app identity for this operation.", operationRef);
-            if (kitAppId && appId !== kitAppId)
-                throw new CliError("APP_IDENTITY_MISMATCH", "Isomorph returned a different app identity than the one linked in .isomorph/kit.lock.json.", operationRef);
-            pending = { ...pending, appId };
-            await writePending(root, pending);
-            if (!pending.appSetupConfirmed) {
-                // An empty description defers to Isomorph's suggestion; a blank name never reaches here (readAppProfile).
-                await confirmProfile(client, operationRef, { displayName: profile.name, ...(profile.description ? { description: profile.description } : {}) }, output);
-                await confirmAudience(client, operationRef, profile.audience, output);
-                pending = { ...pending, appSetupConfirmed: true };
-                await writePending(root, pending);
-            }
-            const manifest = await createSourceManifest({ tenantId, appId, operationId: operationRef, graphDigest: graph.graphDigest, files });
-            const preliminaryArchive = await archiveForManifest(root, manifest);
-            const prepared = structured(await client.call("isomorph_prepare_source_upload", { operationId: operationRef, appId, surface: "codex", graph, format: "zip", filename: `${appId}.zip`, compressedBytes: preliminaryArchive.body.byteLength, manifest: { schema: "isomorph.source-package-manifest/1.0", files: manifest.files.map(file => ({ path: file.path, size: file.bytes, sha256: file.sha256 })) } }));
-            if (!prepared.acceptedManifest || !prepared.sourceUpload)
-                throw new CliError("UPLOAD_CONTRACT_MISSING", "Isomorph did not return a safe upload contract.", operationRef);
-            if (prepared.nextAction?.tool && !matchesTool(prepared.nextAction.tool, "isomorph_complete_source_upload"))
-                throw new CliError("UNSUPPORTED_NEXT_STEP", "Isomorph returned an unsupported next step.", operationRef);
-            const archive = await archiveForManifest(root, prepared.acceptedManifest);
-            // The canonical identity lands in kit.lock so a later `integrations request` reuses it instead
-            // of linking a second app — written here, at the first moment it is safe to write it, and never
-            // earlier. `.isomorph/kit.lock.json` is one of the app's own deployable files; the package is
-            // built from bytes read at the top of this run, and `archiveForManifest` re-reads every file and
-            // compares its sha256 before uploading. Recording the id before that read made the CLI refuse
-            // its own edit — "The app changed while it was being packaged (.isomorph/kit.lock.json)" —
-            // deterministically on the first deployment of every new app, because `recordKitAppId` is a
-            // no-op once the id matches, so only a lock that has no id yet changes. Re-running succeeded and
-            // hid the cause (2026-09-15). Both reads are done by this line and the archive is in memory, so
-            // the app is still linked before anything can fail on the network.
-            await recordKitAppId(root, appId, tenantId);
-            const parts = await putMultipart(prepared.sourceUpload, archive.body, (sent, total) => output(`Isomorph is uploading the app package (${Math.floor(sent * 100 / total)}%).`));
-            pending = { ...pending, uploadCompletion: { intentId: prepared.sourceUpload.intentId, parts, clientSha256: archive.digest } };
-            await writePending(root, pending);
-        }
-        if (!pending.uploaded && pending.uploadCompletion) {
-            await client.call("isomorph_complete_source_upload", { operationId: operationRef, ...pending.uploadCompletion });
-            pending = { ...pending, uploaded: true };
-            await writePending(root, pending);
+        let status = opened.status;
+        if (opened.upload) {
+            const parts = await putMultipart(opened.upload, archive.body, (sent, total) => output(`Isomorph is uploading the app package (${Math.floor(sent * 100 / total)}%).`));
+            status = (await governance.completePackage(appId, operationRef, { intentId: opened.upload.intentId, parts, clientSha256: archive.digest })).status;
+            // From here the server carries the deployment on by itself: it inspects the
+            // package, copies the app to the approved company code system (nothing is
+            // deployed or released by that), verifies the saved copy, and deploys.
             output("Isomorph uploaded the secure app package and is inspecting it.");
         }
-        if (!appId)
-            throw new CliError("APP_IDENTITY_MISSING", "The saved operation has no app identity.", operationRef);
-        // The lock now carries the app id, so the tree differs from the one this operation was opened
-        // against; re-pin the digest a resumed run compares with.
-        if (pending.sourceDigest !== (await sourceDigest(root)).digest) {
-            pending = { ...pending, sourceDigest: (await sourceDigest(root)).digest };
-            await writePending(root, pending);
+        else
+            output("Isomorph already has this app package and is continuing from where it stood.");
+        let summary;
+        if (options.waitForDeployment === false) {
+            // Not followed: what the server has, and the one command that follows it. Neither a success nor a failure yet.
+            summary = { ...outcomeIfSettled(status, operationRef), outcome: "running", nextStep: runningLine(status, 0, operationRef) };
         }
-        if (!prior?.sourceSave)
-            await waitForIntake(client, operationRef);
-        let execution = prior?.sourceSave?.status && prior.sourceSave.status !== "AWAITING_APPROVAL" ? { status: prior.sourceSave.status } : await execute(client, operationRef, appId, graph);
-        if (execution.status === "APPROVAL_REQUIRED" || execution.approvalRequiredBeforeExternalAction === true) {
-            output(`Isomorph is copying ${graph.deploymentScope.includedFiles.length} app files to the approved company code system. Nothing is deployed or released by that.`);
-            execution = await execute(client, operationRef, appId, graph, { schema: "isomorph.stage-approval/1.0", step: "save_source_baseline", approved: true, approvedByUser: true, userApprovalText: SAVE_APPROVAL, userVisibleProgress: SAVE_APPROVAL, nextStepSummary: "Isomorph can safely save the app.", dataOrActions: ["Save the app in the company code system."] });
+        else {
+            try {
+                summary = await follow(fetch, operationRef, output, options.waitOptions);
+            }
+            catch (error) {
+                if (error instanceof CliError)
+                    throw error;
+                throw new CliError("DEPLOYMENT_STATUS_UNAVAILABLE", `Isomorph could not follow the operation (${error instanceof Error ? error.message.replace(/https?:\/\/\S+|Bearer\s+\S+/gi, "").slice(0, 160) : "unknown error"}). Check again with \`isomorph status\`.`, operationRef);
+            }
+            output(outcomeLine(summary));
         }
-        if (execution.status === "ADMIN_SETUP_REQUIRED")
-            throw new CliError("ADMIN_SETUP_REQUIRED", "The company code connection needs one-time administrator setup.", operationRef);
-        if (execution.status === "FAILED")
-            throw new CliError("FAILED", "Isomorph could not save the app.", operationRef);
-        if (execution.status === "RETRYABLE_FAILURE")
-            throw new CliError("RETRYABLE_FAILURE", "Isomorph could not complete the save yet. Resume this operation safely.", operationRef);
-        const evidence = await waitForSave(client, operationRef, graph, execution, output);
-        const report = structured(await client.call("isomorph_build_verification_report", { operationId: operationRef, appId, surface: "codex", graph, sourceControlEvidence: evidence.sourceControlEvidence, runnerEvidence: evidence.runnerEvidence }));
-        output("Isomorph verified the saved app.");
-        const verification = safeVerificationResult(report, evidence);
-        if (options.waitForDeployment === false)
-            return { cliVersion: CLI_VERSION, operationRef, result: verification };
-        return finishDeployment(client, operationRef, output, options, verification);
+        return { cliVersion: CLI_VERSION, operationRef, result: summary };
     }
     catch (error) {
-        throw await operationFailure(client, operationRef, error);
+        throw await operationFailure(fetch, operationRef, error);
+    }
+}
+/** The status as `--no-wait` hands it back: a settled outcome is named, an in-flight one is summarised as it stands. */
+function outcomeIfSettled(status, operationRef) {
+    try {
+        return outcomeFor(status, operationRef);
+    }
+    catch {
+        return summarize(status);
     }
 }
 /** What a builder is told to do when the checks failed here: the detail is in the report; fix, then run again. */
@@ -330,39 +242,9 @@ async function ensureChecksPassed(root, output, options) {
 }
 /** The checks as `isomorph check` runs them, with the bundle this deploy carries. */
 function defaultRunChecks(options) {
-    const bundle = options.integrations?.bundle ?? EMBEDDED_KIT_BUNDLE;
+    const bundle = options.bundle ?? EMBEDDED_KIT_BUNDLE;
     return (root, output) => runChecks(root, { run: options.checks?.run ?? runCommand, bundle, output });
 }
-async function waitForIntake(client, operationRef) {
-    for (let attempt = 0; attempt < 60; attempt += 1) {
-        const status = structured(await client.call("isomorph_get_operation_status", { operationId: operationRef, waitSeconds: 3 }));
-        if (status.operation?.stage === "awaiting-approval" || status.sourceSave?.status === "QUEUED")
-            return;
-        if (status.operation?.stage === "failed")
-            throw intakeRejection(status, operationRef);
-        await new Promise(resolve => setTimeout(resolve, 1_000));
-    }
-    throw new CliError("INSPECTION_TIMEOUT", "Isomorph is still inspecting the app package. Resume this operation safely.", operationRef);
-}
-/**
- * Intake does not merely refuse a package; it records why — a stable code, one
- * plain-English sentence, and the commands that fix it — on the operation. The
- * stage alone was all this used to read, so every refusal reached the maker as
- * the same sentence and the reason stayed on the server. Say what the server
- * said, and keep the generic line only for an operation that failed without
- * any detail at all.
- */
-function intakeRejection(status, operationRef) {
-    return refusal(pickSourceFailure(status), "PACKAGE_REJECTED", "Isomorph could not safely accept this app package.", operationRef);
-}
-/**
- * The one way this file turns "the server refused" into a failure the builder
- * can act on: the server's own code, sentence and fix where it gave them, the
- * generic pair only where it gave nothing, and the operation reference always.
- */
-function refusal(failure, fallbackCode, fallbackMessage, operationRef) {
-    return new CliError(failure?.code ?? fallbackCode, failure?.message ?? fallbackMessage, operationRef, failure?.remediationHint, undefined, { layer: "governance" });
-}
 /**
  * Why the whole operation stopped. The outer catch used to answer this with one
  * fixed sentence for everything that was not already a `CliError`, which is
@@ -372,14 +254,14 @@ function refusal(failure, fallbackCode, fallbackMessage, operationRef) {
  *
  *  1. A `CliError` already carries a reason; keep it, and only make sure it
  *     names the operation, since by here one exists.
- *  2. Otherwise the thrown value's own detail, then the refusal intake recorded
- *     on the operation, and only then the generic line.
+ *  2. Otherwise the thrown value's own detail, then the refusal the server
+ *     recorded on the operation, and only then the generic line.
  */
-async function operationFailure(client, operationRef, error) {
+async function operationFailure(fetch, operationRef, error) {
     if (error instanceof CliError)
         return error.operationRef ? error : withOperation(error, operationRef);
     const detail = errorDetail(error);
-    return refusal(detail ?? await recordedFailure(client, operationRef), "OPERATION_FAILED", "Isomorph could not complete the started operation.", operationRef);
+    return recordedRefusal(detail ?? await recordedFailure(fetch), "OPERATION_FAILED", "Isomorph could not complete the started operation.", operationRef);
 }
 /**
  * What the thrown value itself says. A refusal reaches us as a bare `Error`
@@ -404,75 +286,18 @@ function text(value) {
     return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
 /**
- * The refusal intake recorded on the operation, if any. Best-effort: the reason
- * the builder gets must never depend on a second call succeeding, so a probe
- * that fails simply contributes nothing.
+ * The refusal the server recorded on the operation, if any. Best-effort: the
+ * reason the builder gets must never depend on a second call succeeding, so a
+ * probe that fails simply contributes nothing.
  */
-async function recordedFailure(client, operationRef) {
+async function recordedFailure(fetch) {
     try {
-        return pickSourceFailure(structured(await client.call("isomorph_get_operation_status", { operationId: operationRef, waitSeconds: 0 })));
+        return pickSourceFailure(await fetch(0));
     }
     catch {
         return undefined;
     }
 }
-async function execute(client, operationRef, appId, graph, approval) {
-    const args = { operationId: operationRef, appId, surface: "codex", graph, action: "save_baseline", mode: "EXECUTE" };
-    if (approval)
-        args.approval = approval;
-    return structured(await client.call("isomorph_execute_source_control", args)).sourceControlExecution ?? {};
-}
-async function waitForSave(client, operationRef, graph, first, output) {
-    let waitSeconds = boundedWait(first.nextAction?.waitSeconds);
-    for (let attempt = 0; attempt < 40; attempt += 1) {
-        const status = structured(await client.call("isomorph_get_operation_status", { operationId: operationRef, waitSeconds }));
-        const terminal = status.sourceSave?.status;
-        if (terminal === "SUCCEEDED" || terminal === "DUPLICATE") {
-            const sourceControlEvidence = status.sourceControlEvidence ?? status.sourceSave?.sourceControlEvidence;
-            const runnerEvidence = status.runnerEvidence ?? status.sourceSave?.runnerEvidence;
-            if (!sourceControlEvidence || !runnerEvidence)
-                throw new CliError("EVIDENCE_MISSING", "Isomorph did not return managed save evidence.", operationRef);
-            return { sourceControlEvidence, runnerEvidence };
-        }
-        if (terminal === "FAILED")
-            throw new CliError("FAILED", "Isomorph could not save the app.", operationRef);
-        if (terminal === "RETRYABLE_FAILURE")
-            throw new CliError("RETRYABLE_FAILURE", "Isomorph could not complete the save yet. Resume this operation safely.", operationRef);
-        waitSeconds = boundedWait(status.nextAction?.waitSeconds ?? status.waitSeconds);
-        output("Isomorph is still saving the app.");
-    }
-    throw new CliError("RETRYABLE_FAILURE", "Isomorph could not finish the save within the safe retry window.", operationRef);
-}
-function boundedWait(value) {
-    return Math.min(15, Math.max(0, Number.isFinite(value) ? Math.floor(value) : 15));
-}
-/** Isomorph publishes and accepts exactly one tool spelling, `isomorph_<verb>`; a next step is compared as it is. */
-function matchesTool(actual, expected) {
-    return actual === expected;
-}
-function safeVerificationResult(value, statusEvidence) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return { verification: "completed" };
-    const record = value;
-    const decision = record.decision && typeof record.decision === "object" && !Array.isArray(record.decision)
-        ? record.decision
-        : undefined;
-    return {
-        verification: typeof decision?.status === "string"
-            ? decision.status
-            : typeof record.status === "string"
-                ? record.status
-                : "completed",
-        ...(typeof decision?.assuranceLevel === "string" ? { assuranceLevel: decision.assuranceLevel } : {}),
-        ...(typeof record.protectedUrl === "string" ? { protectedUrl: record.protectedUrl } : {}),
-        ...((record.sourceControlEvidence ?? statusEvidence?.sourceControlEvidence) && typeof (record.sourceControlEvidence ?? statusEvidence?.sourceControlEvidence) === "object" && !Array.isArray(record.sourceControlEvidence ?? statusEvidence?.sourceControlEvidence)
-            ? { sourceControlEvidence: record.sourceControlEvidence ?? statusEvidence?.sourceControlEvidence }
-            : {}),
-        ...((record.runnerEvidence ?? statusEvidence?.runnerEvidence) && typeof (record.runnerEvidence ?? statusEvidence?.runnerEvidence) === "object" && !Array.isArray(record.runnerEvidence ?? statusEvidence?.runnerEvidence)
-            ? { runnerEvidence: record.runnerEvidence ?? statusEvidence?.runnerEvidence }
-            : {})
-    };
-}
 function outcomeLine(summary) {
     switch (summary.outcome) {
         case "live": return `Isomorph deployed the app. Protected preview: ${summary.deployment?.protectedUrl ?? ""}`.trim();
@@ -495,57 +320,30 @@ export async function appCallsAi(root) {
     const callsites = report?.gate?.inventory?.aiCallsites;
     return Array.isArray(callsites) && callsites.length > 0;
 }
-async function finishDeployment(client, operationRef, output, options, verification = {}) {
-    let summary;
-    try {
-        summary = options.waitForDeployment === false ? outcomeFor(await fetchStatus(client, operationRef), operationRef) : await follow(client, operationRef, output, options.waitOptions);
-    }
-    catch (error) {
-        if (error instanceof CliError)
-            throw withOperation(error, operationRef);
-        throw new CliError("DEPLOYMENT_STATUS_UNAVAILABLE", `Isomorph could not follow the existing operation (${error instanceof Error ? error.message.replace(/https?:\/\/\S+|Bearer\s+\S+/gi, "").slice(0, 160) : "unknown error"}). Check again with \`isomorph status\`.`, operationRef);
-    }
-    output(outcomeLine(summary));
-    return { cliVersion: CLI_VERSION, operationRef, result: { ...verification, ...summary } };
-}
 /** The three values as the command prints them before it starts. */
 export function describeProfile(profile) {
-    return [`App name: ${profile.name}`, `Description: ${profile.description || "(none yet; Isomorph suggests one)"}`, `Audience: ${profile.audience.length ? profile.audience.join(", ") : "only you"}`];
-}
-function operationFinished(status) {
-    if (status.production)
-        return ["LIVE", "FAILED", "MANUAL_RECOVERY"].includes(status.production.state);
-    if (status.deployment)
-        return ["LIVE", "FAILED", "STALE", "RETRYABLE_FAILURE"].includes(status.deployment.state);
-    return status.operation?.stage === "failed";
+    return [`App name: ${profile.name}`, `Description: ${profile.description || "(none yet)"}`, `Audience: ${profile.audience.length ? profile.audience.join(", ") : "only you"}`];
 }
-async function readPending(root, tenantId, endpoint) {
-    let raw;
+/** The last deployment this folder opened for this company, or nothing: a note that cannot be read is no note. */
+export async function readDeployNote(root, tenantId) {
     try {
-        raw = await readFile(resolve(root, ".isomorph/local/productionise.json"), "utf8");
+        const record = JSON.parse(await readFile(kitPaths(root).deployNote, "utf8"));
+        return record.schema === "isomorph.deploy-note/1.0" && record.tenantId === tenantId && typeof record.operationRef === "string" && typeof record.sha256 === "string" ? record : undefined;
     }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return undefined;
-        throw error;
+    catch {
+        return undefined;
     }
-    const record = JSON.parse(raw);
-    if (!record.operationRef || !record.graph || typeof record.uploaded !== "boolean" || !record.sourceDigest)
-        throw new CliError("OPERATION_RECORD_INVALID", "The saved deployment reference cannot be read. Recover the operation from Isomorph before starting another.");
-    return record.tenantId === tenantId && record.endpoint === endpoint ? record : undefined;
 }
-async function writePending(root, record) {
-    const path = resolve(root, ".isomorph/local/productionise.json");
+async function writeDeployNote(root, note) {
+    const path = kitPaths(root).deployNote;
     try {
         await mkdir(dirname(path), { recursive: true });
         const temporary = `${path}.${process.pid}.tmp`;
-        await writeFile(temporary, JSON.stringify(record), { mode: 0o600 });
+        await writeFile(temporary, `${JSON.stringify(note, null, 2)}\n`, { mode: 0o600 });
         await rename(temporary, path);
     }
-    catch {
-        throw new CliError("OPERATION_RECORD_WRITE_FAILED", "Isomorph started the operation but could not save its local reference. Continue with isomorph status using this operation reference.", record.operationRef);
-    }
+    catch { /* The server owns resume; the note only saves the builder typing the reference. */ }
 }
 function withOperation(error, operationRef) {
-    return new CliError(error.code, error.message, operationRef, error.remediationHint, error.result, { layer: error.layer, ...(error.paths ? { paths: error.paths } : {}) });
+    return new CliError(error.code, error.message, operationRef, error.remediationHint, error.result, { layer: error.layer, ...(error.paths ? { paths: error.paths } : {}), ...(error.details ? { details: error.details } : {}) });
 }

package/dist/packages/harbour-cli/src/guide.js

@@ -32,7 +32,7 @@ CREATE POLICY notes_owner ON notes
 
 Shared-read, owner-write: the same, plus \`CREATE POLICY posts_read ON posts FOR SELECT USING (true);\`.
 
-\`.isomorph/checks/\` is generated by \`isomorph check\`, which adds and deletes files as the app changes; never write or edit it by hand.
+\`.isomorph/checks/\` is generated by every check and not committed; your own checks go in \`tests/*.mjs\`. A refusal for uncovered surface names the file to write.
 
 ## Files and realtime
 
@@ -99,7 +99,7 @@ AI goes through \`isomorph.ai\` only: one \`isomorph.ai.chat({ messages, maxToke
 const reply = await isomorph.ai.chat({ messages: [{ role: "user", content: \`Summarise these notes in three lines:\\n\${notes.map(n => n.title).join("\\n")}\` }], maxTokens: 200 });
 \`\`\`
 
-The starter calls no AI; add the one call when the person asks. \`isomorph check\` writes \`.isomorph/checks/ai-journey.mjs\` for it (and deletes it when the call goes): locally the journey makes a real governed call through the development route with your \`isomorph login\`; in the pipeline it is answered by a canned completion and reported as not tested.`,
+The starter calls no AI; add the one call when the person asks. The check's generated ai journey makes a real governed call locally through the development route with your \`isomorph login\`; in the pipeline it is answered by a canned completion and reported as not tested.`,
     jobs: `# Scheduled jobs
 
 Scheduled work lives only in \`jobs/<name>.ts\`: export one literal UTC cron as \`schedule\` and one default async handler. Never use \`setInterval\`, an effect or a browser timer as a scheduler; Isomorph runs the same declaration automatically after deployment, and the deployed Kubernetes schedule owns the real clock. Test it immediately: start \`isomorph dev\`, then \`isomorph jobs run <name> --app-root . --scheduled-at <matching-UTC-time> --json\` — local data and safe fixtures, nothing sent. Use \`--real\` only when the person explicitly asks to test the company action now and the exact action has development approval.