@isomorph.ai/cli 0.8.2 → 0.9.0

package/dist/packages/harbour-cli/src/agent-setup.js

@@ -108,7 +108,7 @@ Rules live beside this file: \`core.md\` before the first edit; \`integrations.m
 
 ## Getting ready
 
-- No \`.isomorph/\` yet: \`isomorph init --app-root .\` (empty folder → starter; an existing app → three choices to relay). Node 22+, no Docker.
+- No \`.isomorph/\` yet: \`isomorph init --app-root .\` (empty folder → starter; an existing app → three choices to relay). Node 22+, no Docker. Then write the app's \`name\` and \`description\` into \`.isomorph/app.json\` from what they asked and tell them both: IT sees the app under exactly these, once, on its first approval.
 - Sign-in, only when a command answers \`CONFIG_REQUIRED\` or \`AUTH_REQUIRED\` (most machines already are): \`isomorph connect <work-email>\`, then \`isomorph login\` — the browser opens and the person finishes there (their one step; say so).
 
 ## Intent → command

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

@@ -27,13 +27,13 @@ export function checksFailedMessage(report) {
 /** The bound on the reason carried into the refusal; the rest stays in the report. */
 const DETAIL_CAP = 200;
 /** Where the rest of it is, and the one command that re-runs them. */
-export const CHECKS_FAILED_HINT = "Full detail is in .isomorph/local/check-report.json; fix what it reports, then run `isomorph check --app-root .` again.";
+export const CHECKS_FAILED_HINT = "Full detail is in .isomorph/check-report.json; fix what it reports, then run `isomorph check --app-root .` again.";
 /** The name the gate reports operation coverage under — the pipeline's rule for it. */
 export const FLOW_CHECK = "flow.check-failed";
 /** The CLI's own check over `jobs/`: a company operation a job calls that would run as a person. */
 export const JOBS_CHECK = "jobs.identity";
 /**
- * Runs the kit checks and writes `.isomorph/local/check-report.json`; a source
+ * Runs the kit checks and writes `.isomorph/check-report.json`; a source
  * edit changes sourceDigest and so invalidates the previous report. The app's
  * own toolchain first (typecheck, build), then the kit gate — the pipeline's
  * gate, run by the pinned native gateway in this app's local session — whose

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

@@ -1,13 +1,14 @@
 import { basename, dirname, resolve } from "node:path";
 import { readFile, mkdir, rename, writeFile } from "node:fs/promises";
 import { createSourceManifest } from "../../../src/source-intake.js";
+import { sourceDigestOf } from "../../../src/source-digest.js";
 import { archiveForManifest, putMultipart } from "./upload.js";
 import { CliError } from "./output.js";
 import { continueCommand, follow, outcomeFor, pickSourceFailure, recordedRefusal, runningLine, statusFetch, summarize } from "./operations.js";
 import { CLI_VERSION } from "./version.js";
 import { assertSafeAppRoot, readAppTree } from "./package.js";
 import { deployBlocked, ensureLinkedApp, kitLockBody } from "./integrations.js";
-import { assertLockCompany, describeSourceChange, kitPaths, readAppProfile, readDeclaration, readKitLock, sourceDigest } from "./kit.js";
+import { assertLockCompany, describeSourceChange, kitPaths, readReviewedAppProfile, 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";
@@ -56,15 +57,14 @@ async function runDeploy(rootArg, governance, output, tenantId, options) {
     assertLockCompany(lock, tenantId);
     // The three values the person confirmed, printed so the transcript shows what
     // was recorded; recorded on the operation before anything is uploaded.
-    const profile = await readAppProfile(root);
+    // Refused here, in the first second, and by the same rule as the first access
+    // request (`APP_PROFILE_UNREVIEWED`): a deploy with the starter profile used
+    // to run 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 a blank one too; this only says so before the checks spend a minute.
+    const profile = await readReviewedAppProfile(root);
     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 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.");
     const declaration = await readDeclaration(root);
     // 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
@@ -81,12 +81,14 @@ async function runDeploy(rootArg, governance, output, tenantId, options) {
     // it runs, so the tree is scanned only after it.
     await ensureChecksPassed(root, output, options);
     const { graph, files } = await readAppTree(root);
+    const report = await packagedReport(root, files);
     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 });
+    // The package: built once, from the bytes read above plus the report those
+    // bytes passed; `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: [...files, report.file] });
     const archive = await archiveForManifest(root, manifest);
     const note = await readDeployNote(root, tenantId);
     if (note?.sha256 === archive.digest)
@@ -102,7 +104,7 @@ async function runDeploy(rootArg, governance, output, tenantId, options) {
         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), kitLock: kitLockBody(lock.bundle)
+        graph, cliVersion: CLI_VERSION, kitBundleVersion: bundle.kitVersion, declaration, callsAi: await appCallsAi(root), kitLock: kitLockBody(lock.bundle), checkReport: report.summary
     };
     let opened;
     try {
@@ -195,7 +197,7 @@ function skippedGates(report) {
  * Makes sure the checks have passed *for this tree*, running them when they
  * have not.
  *
- * `isomorph check` writes `.isomorph/local/check-report.json` with the digest of
+ * `isomorph check` writes `.isomorph/check-report.json` with the digest of
  * the source it ran against. A report is trusted when three things are true:
  * the checks ran, they ran against these bytes, and the ones that matter
  * actually ran rather than being skipped. Then nothing is run again — the gate
@@ -241,6 +243,28 @@ async function ensureChecksPassed(root, output, options) {
     if (skipped.length)
         throw new CliError("CHECKS_NOT_RUN", `The checks skipped ${skipped.length} gate${skipped.length === 1 ? "" : "s"} instead of passing ${skipped.length === 1 ? "it" : "them"}. The deployment pipeline runs the same ones in the cloud, so skipping them here only moves the failure.`, undefined, "Start `isomorph dev --app-root .`, run `isomorph check --app-root .`, then run this again.", undefined, { paths: skipped });
 }
+/** The report's path inside the package: beside the lock, where intake looks for it. */
+const REPORT_PACKAGE_PATH = ".isomorph/check-report.json";
+/**
+ * The report `ensureChecksPassed` trusted, read once as the bytes the package
+ * carries and the three values the deploy route reads. Intake recomputes the
+ * tree's digest and refuses a package whose report is for other bytes, so the
+ * pair is held to that rule here first, against the files going into the
+ * archive rather than a second scan.
+ */
+async function packagedReport(root, files) {
+    let content;
+    try {
+        content = new Uint8Array(await readFile(kitPaths(root).report));
+    }
+    catch {
+        throw new CliError("CHECKS_NOT_RUN", `Isomorph could not read ${REPORT_PACKAGE_PATH}.`, undefined, "Run `isomorph check --app-root .`, then run this again.");
+    }
+    const report = JSON.parse(new TextDecoder().decode(content));
+    if (report.passed !== true || report.sourceDigest !== sourceDigestOf(files))
+        throw new CliError("CHECKS_STALE", "The app changed while it was being packaged, so its check report is not for this code.", undefined, "Run the same deploy command again: it checks the app as it is now.");
+    return { file: { path: REPORT_PACKAGE_PATH, content }, summary: { sourceDigest: report.sourceDigest, passed: report.passed, createdAt: report.createdAt } };
+}
 /** The checks as `isomorph check` runs them, with the bundle this deploy carries. */
 function defaultRunChecks(options) {
     const bundle = options.bundle ?? EMBEDDED_KIT_BUNDLE;
@@ -310,7 +334,7 @@ function outcomeLine(summary) {
 }
 /**
  * Whether the app really calls governed AI: the gate's inventory of
- * `isomorph.ai.*` call sites (`.isomorph/local/check-report.json`,
+ * `isomorph.ai.*` call sites (`.isomorph/check-report.json`,
  * `gate.inventory.aiCallsites`). Not the capability word — a starter that
  * merely carried an `ai()` accessor was derived as `ai` and would have been
  * refused `AI_NOT_READY` at a company without AI for an app that never asks

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

@@ -6,7 +6,7 @@ import { createForwarder } from "./forwarder.js";
 import { readKitLock } from "./kit.js";
 import { GovernanceClient, ensureLinkedApp, fileDeclaredRequests, IDENTITY_WORDS, renderGrantGroup } from "./integrations.js";
 import { acquireDevLock, allocatePorts, assertMigrationNames, installDependencies, LocalRuntime, nodePackageCommand, pidAlive, readDevLock, recordDevChildren, releaseDevLock, runCommand } from "./local-runtime.js";
-import { declarationDigest, kitPaths } from "./kit.js";
+import { accessDigest, kitPaths } from "./kit.js";
 import { CliError, safeError } from "./output.js";
 /**
  * Signed in at startup: link the app and file the access request for every
@@ -29,16 +29,21 @@ export async function companyAccessAtStartup(root, client, tenantId, bundle) {
         return { appId: filed.appId, lines };
     }
     catch (error) {
+        // Not a fault: the ask waits on the person. Said in full, since this line is the only place the builder learns why IT has nothing yet; the watcher files once app.json changes.
+        if (error instanceof CliError && error.code === "APP_PROFILE_UNREVIEWED")
+            return { lines: [`Company access not requested yet: ${error.message} ${error.remediationHint ?? ""}`.trim()], failed: true };
         return { lines: [`Company access could not be checked (${safeError(error).message}); the app runs without it until the next start.`], failed: true };
     }
 }
 /**
- * Files the declared requests again whenever `.isomorph/integrations.json`
- * changes while `isomorph dev` runs — `isomorph check` rewrites it as the app's
- * calls change — so adding a company system needs no restart. Before this the
- * session filed once at start, nothing watched the file, and a builder's new
- * connection was never requested (2026-09-17 round). `poll` is one tick; a
- * filing that failed is retried on the next tick with the same digest.
+ * Files the declared requests again whenever `.isomorph/integrations.json` or
+ * `.isomorph/app.json` changes while `isomorph dev` runs — `isomorph check`
+ * rewrites the first as the app's calls change, the builder edits the second
+ * when the person names the app — so adding a company system, or reviewing the
+ * profile the first request waits on, needs no restart. Before this the session
+ * filed once at start, nothing watched the file, and a builder's new connection
+ * was never requested (2026-09-17 round). `poll` is one tick; a filing that
+ * failed is retried on the next tick with the same digest.
  */
 export function declarationWatcher(root, refile, output, filed) {
     let known = filed;
@@ -49,12 +54,12 @@ export function declarationWatcher(root, refile, output, filed) {
                 return;
             busy = true;
             try {
-                const digest = await declarationDigest(root);
+                const digest = await accessDigest(root);
                 if (digest === known)
                     return;
                 const result = await refile();
                 if (result.lines.length)
-                    output([".isomorph/integrations.json changed: company access requested again.", ...result.lines].map(line => `  ${line}`).join("\n"));
+                    output([".isomorph/integrations.json or app.json changed: company access requested again.", ...result.lines].map(line => `  ${line}`).join("\n"));
                 if (!result.failed)
                     known = digest;
             }
@@ -158,7 +163,7 @@ export async function startDev(root, options) {
         ].join("\n"));
         // Signed in: link now and file the app-wide requests — after the link is out, so governance's round-trips never hold it — and say where each connection stands.
         if (governance && company) {
-            const filed = await declarationDigest(root);
+            const filed = await accessDigest(root);
             const access = await companyAccessAtStartup(root, governance, company.tenantId, options.bundle);
             lockAppId = access.appId ?? lockAppId;
             const lines = [...(access.appId && !linkedAtStart ? [`Linked app: ${access.appId}`] : []), ...access.lines];

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

@@ -1,5 +1,5 @@
 import { basename } from "node:path";
-import { linkIdempotencyKey, readDeclaration, readKitLock, requestResourceName, requestResources, writeKitLock, newKitLock } from "./kit.js";
+import { linkIdempotencyKey, readDeclaration, readKitLock, readReviewedAppProfile, requestResourceName, requestResources, writeKitLock, newKitLock } from "./kit.js";
 import { CliError } from "./output.js";
 import { CLI_VERSION } from "./version.js";
 /** The lock's bundle as the preflight body carries it. */
@@ -18,7 +18,7 @@ export class GovernanceClient {
     link(input) {
         return this.call("POST", "/v1/development/apps/link", { tenantId: this.tenantId, ...input });
     }
-    /** One app-wide request per (connection, identity): no environment and no expiry — IT approves once for every lane and sets any expiry itself. */
+    /** One app-wide request per (connection, identity): no environment and no expiry — IT approves once for every lane and sets any expiry itself. `app` is the reviewed name and description IT sees the ask under; governance records them before the request. */
     request(appId, input) {
         return this.call("POST", `/v1/development/apps/${encodeURIComponent(appId)}/integration-requests`, { tenantId: this.tenantId, ...input });
     }
@@ -119,12 +119,18 @@ export function transportFailure(error) {
     const text = words(cause) || (Array.isArray(cause?.errors) ? cause.errors.map(words).filter(Boolean).join("; ") : "") || String(cause);
     return typeof cause?.code === "string" && !text.includes(cause.code) ? `${text} (${cause.code})` : text;
 }
-/** Links the app once (stable idempotency key) and records the appId in kit.lock. */
+/**
+ * Links the app once (stable idempotency key) and records the appId in kit.lock.
+ * The link's name is provisional — IT sees nothing of an app until its first
+ * access request, which carries the reviewed profile — so a profile not yet
+ * reviewed (or absent) links under the folder name and is renamed by that request.
+ */
 export async function ensureLinkedApp(root, client, tenantId, bundle) {
     const lock = (await readKitLock(root)) ?? newKitLock(bundle, tenantId);
     if (lock.appId)
         return lock.appId;
-    const linked = await client.link({ displayName: basename(root), idempotencyKey: linkIdempotencyKey(tenantId, root) });
+    const displayName = await readReviewedAppProfile(root).then(profile => profile.name, () => basename(root));
+    const linked = await client.link({ displayName, idempotencyKey: linkIdempotencyKey(tenantId, root) });
     if (!linked.appId)
         throw new CliError("LINK_FAILED", "Isomorph did not return an app identity for this app.");
     await writeKitLock(root, { ...lock, appId: linked.appId, tenantId });
@@ -135,11 +141,11 @@ export const IDENTITY_WORDS = { app: "as the company bot", user: "as the signed-
 /** A refusal about the leg rather than the ask — signed out, unreachable, an answer with no code — is nobody's ask and stops the run. */
 const legFailure = (code) => code === "AUTH_REQUIRED" || code === "GOVERNANCE_UNREACHABLE" || code.startsWith("HTTP_");
 /** One request per identity mode of the connection. A refusal of an ask is returned beside the others, not thrown, so a caller can report every connection at once. */
-async function submitRequests(client, appId, declaration, root, connection, reason, only) {
+async function submitRequests(client, appId, declaration, root, connection, app, reason, only) {
     return Promise.all(requestScope(declaration, connection, only).map(async (part) => {
         const ask = { connection, ...part };
         try {
-            return { ...ask, outcome: await client.request(appId, { connection, identityMode: part.identityMode, operations: part.operations, resources: part.resources, ...(part.presentation ? { presentation: part.presentation } : {}), ...(reason?.trim() ? { reason: reason.trim() } : {}) }) };
+            return { ...ask, outcome: await client.request(appId, { connection, identityMode: part.identityMode, operations: part.operations, resources: part.resources, ...(part.presentation ? { presentation: part.presentation } : {}), ...(reason?.trim() ? { reason: reason.trim() } : {}), app }) };
         }
         catch (error) {
             const refusal = unregisteredResourceGuidance(error, declaration, connection, root);
@@ -149,6 +155,8 @@ async function submitRequests(client, appId, declaration, root, connection, reas
         }
     }));
 }
+/** The two profile values an access request carries. */
+const reviewedProfileBody = (profile) => ({ name: profile.name, description: profile.description });
 /** The filed asks with every refusal thrown, for the commands that cannot go on past one. */
 function settled(requests) {
     return requests.map(item => { if (item.error)
@@ -163,15 +171,18 @@ function settled(requests) {
  * one it is still deciding, so a repeat opens nothing. Links the app first
  * (the same key as `integrations request`) and reads the lanes back, grouped.
  * An app with no declaration or no connections is left alone: nothing to ask,
- * so governance is not called.
+ * so governance is not called. A profile nobody has reviewed is refused
+ * (`APP_PROFILE_UNREVIEWED`) before anything is filed: the request is the
+ * first thing IT sees of the app, under that name and description.
  */
 export async function fileDeclaredRequests(root, client, tenantId, bundle) {
     const declaration = await readDeclaration(root);
     const connections = Object.keys(declaration.connections);
     if (!connections.length)
         return undefined;
+    const app = reviewedProfileBody(await readReviewedAppProfile(root));
     const appId = await ensureLinkedApp(root, client, tenantId, bundle);
-    const requests = (await Promise.all(connections.map(connection => submitRequests(client, appId, declaration, root, connection)))).flat();
+    const requests = (await Promise.all(connections.map(connection => submitRequests(client, appId, declaration, root, connection, app)))).flat();
     return { appId, requests, groups: groupGrants((await client.list(appId)).grants) };
 }
 /**
@@ -181,8 +192,9 @@ export async function fileDeclaredRequests(root, client, tenantId, bundle) {
  */
 export async function requestIntegrations(root, client, tenantId, bundle, options) {
     const declaration = await readDeclaration(root);
+    const app = reviewedProfileBody(await readReviewedAppProfile(root));
     const appId = await ensureLinkedApp(root, client, tenantId, bundle);
-    const submitted = settled(await submitRequests(client, appId, declaration, root, options.connection, options.reason, options.operations)).map(item => ({ ...item, state: item.outcome.state }));
+    const submitted = settled(await submitRequests(client, appId, declaration, root, options.connection, app, options.reason, options.operations)).map(item => ({ ...item, state: item.outcome.state }));
     const sleep = options.sleep ?? ((ms) => new Promise(resolve => setTimeout(resolve, ms)));
     const pollMs = options.pollMs ?? 3_000;
     let grants = [];

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

@@ -3,6 +3,7 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, join, parse, resolve } from "node:path";
 import { scanWorkspace } from "../../../src/analyzer.js";
+import { sourceDigestOf } from "../../../src/source-digest.js";
 import { isKitBundle } from "./kit-bundle.js";
 import { CliError } from "./output.js";
 /** Explicit reads `isomorph check --integrations` may run; every other operation is a send and never runs during checks. */
@@ -131,7 +132,7 @@ export function newKitLock(bundle, tenantId = "", appId = "") {
     return { schema: "isomorph.kit-lock/1.0", appId, tenantId, bundle, createdAt: now, updatedAt: now };
 }
 // ---- Paths and identity --------------------------------------------------------
-/** Where a kit app keeps its declaration, lock and app profile (committed), and its generated checks and local state (ignored). */
+/** Where a kit app keeps its declaration, lock and app profile (committed), the check report `deploy` packages, and its generated checks and local state (ignored). */
 export const KIT_DIRECTORY = ".isomorph";
 export function appRoot(rootArg) {
     if (!rootArg)
@@ -144,13 +145,62 @@ export function appRoot(rootArg) {
 export function kitPaths(root) {
     const kit = join(root, KIT_DIRECTORY);
     const local = join(kit, "local");
-    return { kit, local, declaration: join(kit, "integrations.json"), app: join(kit, "app.json"), lock: join(kit, "kit.lock.json"), devLock: join(local, "dev.lock"), state: join(local, "state"), report: join(local, "check-report.json"), deployNote: join(local, "deploy.json") };
+    return { kit, local, declaration: join(kit, "integrations.json"), app: join(kit, "app.json"), lock: join(kit, "kit.lock.json"), devLock: join(local, "dev.lock"), state: join(local, "state"), report: join(kit, "check-report.json"), deployNote: join(local, "deploy.json") };
 }
+/** The description `init` writes: recognisable later, so a profile nobody has reviewed is never sent to IT. */
+const STARTER_DESCRIPTION_SUFFIX = ": an app built on Isomorph.";
 export function defaultAppProfile(root) {
-    // A real description from the start: the person changes it, but a first
-    // deploy is never refused for a field they have not been shown yet.
+    // A recognisable starter: `profileReviewProblem` refuses it before the first
+    // access request, so the person is shown the name and description exactly
+    // once, before IT sees either, and never again after.
     const name = basename(resolve(root));
-    return { schema: "isomorph.app/1.0", name, description: `${name}: an app built on Isomorph.`, audience: [] };
+    return { schema: "isomorph.app/1.0", name, description: `${name}${STARTER_DESCRIPTION_SUFFIX}`, audience: [] };
+}
+/** Governance's bounds for the profile (maker-app-actions `validateAppProfileInput`), applied here so the refusal is local and names the field. */
+const PROFILE_NAME_LENGTH = { min: 3, max: 80 };
+const PROFILE_DESCRIPTION_LENGTH = { min: 20, max: 240 };
+/**
+ * Why the profile cannot go to IT yet, or `undefined` when it can. The first
+ * access request carries the app's name and description into IT's queue, and
+ * a name IT has seen cannot be unseen: before 0.8.3 that request went out with
+ * the folder name (`my-slack-thing-v2`) and no description, and the real name
+ * only arrived with `deploy` — relabelling the ask under the admin (2026-09-18).
+ * So the starter values `init` wrote are refused until the builder has shown
+ * them to the person and written what they said; a reviewed profile passes
+ * every later run unchanged.
+ */
+export function profileReviewProblem(profile, root) {
+    const name = profile.name.trim();
+    const description = profile.description.trim();
+    if (!name)
+        return "`name` is empty";
+    if (name === basename(resolve(root)))
+        return "`name` is still the folder name";
+    if (!description)
+        return "`description` is empty";
+    if (description.endsWith(STARTER_DESCRIPTION_SUFFIX))
+        return "`description` is still the starter text";
+    if (name.length < PROFILE_NAME_LENGTH.min || name.length > PROFILE_NAME_LENGTH.max)
+        return `\`name\` must be ${PROFILE_NAME_LENGTH.min}-${PROFILE_NAME_LENGTH.max} characters`;
+    if (description.length < PROFILE_DESCRIPTION_LENGTH.min || description.length > PROFILE_DESCRIPTION_LENGTH.max)
+        return `\`description\` must be ${PROFILE_DESCRIPTION_LENGTH.min}-${PROFILE_DESCRIPTION_LENGTH.max} characters`;
+    return undefined;
+}
+/** The profile as the first access request may carry it, or the one refusal that says what to review. */
+export async function readReviewedAppProfile(root) {
+    const profile = await readAppProfile(root);
+    const problem = profileReviewProblem(profile, root);
+    if (problem)
+        throw new CliError("APP_PROFILE_UNREVIEWED", `IT will see this app by its name and description, and .isomorph/app.json has not been reviewed yet: ${problem}.`, undefined, "Show the person the `name` and `description` in .isomorph/app.json, write what they say (a name for colleagues, one sentence on what the app does), then run this again. This is asked once: a reviewed profile is never asked about again.");
+    return profile;
+}
+/** What changes the app's standing with the company: the declaration and the profile the first request carries. */
+export async function accessDigest(root) {
+    const paths = kitPaths(root);
+    const hash = createHash("sha256");
+    for (const path of [paths.declaration, paths.app])
+        hash.update(await readFile(path).catch(() => Buffer.alloc(0))).update("\0");
+    return `sha256:${hash.digest("hex")}`;
 }
 /** `.isomorph/app.json` as `init` writes it. */
 export function renderAppProfile(profile) {
@@ -201,24 +251,20 @@ export function linkIdempotencyKey(tenantId, root) {
     return createHash("sha256").update(`${tenantId}${resolve(root)}`).digest("hex");
 }
 /**
- * sha256 over the tracked app files (same boundary as deploy), so any
- * edit changes it — and, per file, the hash of its contents, so a stale check
- * can say WHICH path moved rather than only that something did. The boundary
- * leaves `.isomorph/checks/` out (analyzer.ts): the gate regenerates it on
- * every check, and a regeneration is not a change to the app.
+ * sha256 over the tracked app files (same boundary as deploy; `sourceDigestOf`
+ * is the one function intake recomputes it with), so any edit changes it —
+ * and, per file, the hash of its contents, so a stale check can say WHICH
+ * path moved rather than only that something did. The boundary leaves
+ * `.isomorph/checks/` and the report itself out (analyzer.ts): the gate
+ * regenerates the one on every check, and writing the other is not a change
+ * to the app.
  */
 export async function sourceDigest(root) {
     const graph = await scanWorkspace(root, { sourceBoundary: "root" });
     const files = [...graph.deploymentScope.includedFiles].sort();
-    const hash = createHash("sha256");
-    const entries = {};
-    for (const path of files) {
-        const content = await readFile(join(root, path));
-        hash.update(path).update("\0");
-        hash.update(content).update("\0");
-        entries[path] = createHash("sha256").update(content).digest("hex");
-    }
-    return { digest: `sha256:${hash.digest("hex")}`, files, entries };
+    const contents = await Promise.all(files.map(async (path) => ({ path, content: new Uint8Array(await readFile(join(root, path))) })));
+    const entries = Object.fromEntries(contents.map(file => [file.path, createHash("sha256").update(file.content).digest("hex")]));
+    return { digest: sourceDigestOf(contents), files, entries };
 }
 /**
  * What moved between the tree the checks ran on and the tree being deployed.

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

@@ -126,7 +126,7 @@ async function appendManaged(root, file, block, result, separator, start, end) {
 const exists = (path) => stat(path).then(() => true, () => false);
 const readJson = (path) => readFile(path, "utf8").then(text => JSON.parse(text), () => undefined);
 // ---- Templates -----------------------------------------------------------------
-const GITIGNORE_LINES = ["node_modules/", "dist/", ".isomorph/local/", ".isomorph/checks/"].join("\n");
+const GITIGNORE_LINES = ["node_modules/", "dist/", ".isomorph/local/", ".isomorph/checks/", ".isomorph/check-report.json"].join("\n");
 /**
  * The per-app block: it says where the rules are and when to read each, and nothing
  * else — the rules themselves live in the modules `agent-setup` writes beside the

package/dist/src/analyzer.js

@@ -250,19 +250,41 @@ function pushMatches(content, pattern, names) {
         names.push(match[1] ?? match[2] ?? "");
     }
 }
+/** A read that only exists on a comment line is not a read: `// stripeSecretKey:
+ * process.env.STRIPE_SECRET_KEY,` asked a builder for a key on 20 Sept 2026. */
+const COMMENT_LINE = /^\s*(?:\/\/|#|\*|\/\*|<!--)/;
+/** `const { SMTP_HOST, SMTP_PASS } = process.env` reads every destructured name. */
+const ENV_DESTRUCTURE = /\{([^}]*)\}\s*=\s*process\.env\b/g;
+/** `NAME=` at the start of a shell line declares a local variable; `$NAME`
+ * later in that file is not an environment read. */
+const SHELL_LOCAL_ASSIGNMENT = /^\s*(?:export\s+)?([A-Z0-9_]{3,})=/gm;
+function uncommentedLines(content) {
+    return content.split(/\r?\n/).filter(line => !COMMENT_LINE.test(line)).join("\n");
+}
 function detectEnvNames(files) {
     const names = [];
     for (const file of files) {
-        const content = file.content ?? "";
+        const content = uncommentedLines(file.content ?? "");
         for (const pattern of ENV_ACCESS_PATTERNS)
             pushMatches(content, pattern, names);
-        if (isShellContextFile(file.basename))
-            pushMatches(content, SHELL_EXPANSION_PATTERN, names);
+        for (const match of content.matchAll(ENV_DESTRUCTURE)) {
+            for (const part of (match[1] ?? "").split(",")) {
+                const name = /^\s*([A-Z0-9_]{3,})\s*(?::|=|$)/.exec(part)?.[1];
+                if (name)
+                    names.push(name);
+            }
+        }
+        if (isShellContextFile(file.basename)) {
+            const locals = new Set([...content.matchAll(SHELL_LOCAL_ASSIGNMENT)].map(match => match[1] ?? ""));
+            const expanded = [];
+            pushMatches(content, SHELL_EXPANSION_PATTERN, expanded);
+            names.push(...expanded.filter(name => !locals.has(name)));
+        }
         // package.json scripts run in a shell; expansion applies to the script
         // strings alone, never to the raw JSON (dependency names, config values).
         if (file.basename === "package.json") {
             try {
-                const scripts = JSON.parse(content).scripts ?? {};
+                const scripts = JSON.parse(file.content ?? "").scripts ?? {};
                 for (const value of Object.values(scripts)) {
                     if (typeof value === "string")
                         pushMatches(value, SHELL_EXPANSION_PATTERN, names);
@@ -271,7 +293,7 @@ function detectEnvNames(files) {
             catch { /* Invalid manifests contribute no names. */ }
         }
         if (isEnvTemplateFile(file.basename)) {
-            for (const line of content.split(/\r?\n/)) {
+            for (const line of (file.content ?? "").split(/\r?\n/)) {
                 const envMatch = /^([A-Z0-9_]{3,})=/.exec(line.trim());
                 if (envMatch)
                     names.push(envMatch[1] ?? "");

package/dist/src/secret-paths.js

@@ -18,15 +18,17 @@ export function isSourceIntakeExcludedPath(path) {
         || /(^|\/)\.github\/workflows\//i.test(path);
 }
 /**
- * The development kit commits exactly these files under `.isomorph`: the
- * integrations declaration, the kit lock and the app profile. Everything else
- * there stays local — local state, and the generated `checks/` and
+ * The development kit ships exactly these files under `.isomorph`: the
+ * integrations declaration, the kit lock, the app profile, and the check
+ * report `isomorph check` wrote for the tree being deployed (packaged by
+ * `deploy`, never scanned into the tree it digests). Everything else there
+ * stays local — local state, and the generated `checks/` and
  * `ai-inventory.json`, which the pipeline's kit lane regenerates from the
  * source it builds (data plane ADR 0014); a builder's own checks are
  * `tests/*.mjs` at the app root, ordinary source.
  */
 export function isKitCommittedPath(path) {
-    return /(^|\/)\.isomorph\/(?:integrations\.json|kit\.lock\.json|app\.json)$/.test(path);
+    return /(^|\/)\.isomorph\/(?:integrations\.json|kit\.lock\.json|app\.json|check-report\.json)$/.test(path);
 }
 /**
  * Dependency and internal directories the intake never stages: `node_modules`,

package/dist/src/source-digest.js

@@ -0,0 +1,16 @@
+import { createHash } from "node:crypto";
+/**
+ * The digest `isomorph check` pins in its report and `isomorph deploy` and
+ * source intake recompute: sha256 over the app's files sorted by path, each as
+ * `path\0content\0`. One function on both sides of the upload, so a report
+ * that matched on the laptop matches at intake for the same bytes, and the
+ * order the files arrive in never matters.
+ */
+export function sourceDigestOf(files) {
+    const hash = createHash("sha256");
+    for (const file of [...files].sort((left, right) => (left.path < right.path ? -1 : left.path > right.path ? 1 : 0))) {
+        hash.update(file.path).update("\0");
+        hash.update(file.content).update("\0");
+    }
+    return `sha256:${hash.digest("hex")}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isomorph.ai/cli",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "description": "Isomorph development kit CLI",
   "type": "module",
   "bin": {
@@ -19,6 +19,7 @@
     "dist/src/contracts.js",
     "dist/src/digest.js",
     "dist/src/secret-paths.js",
+    "dist/src/source-digest.js",
     "dist/src/source-intake.js",
     "package.json"
   ],