@isomorph.ai/cli 0.7.4 → 0.8.0

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

@@ -118,12 +118,12 @@ Rules live beside this file: \`core.md\` before the first edit; \`integrations.m
 | "run it", "show me" | \`isomorph dev --app-root . --detach --json\`; give them \`result.origin\` (the first start takes a minute or two). Locally they are a fixture user. |
 | "check it", "is it ready?" | \`isomorph check --app-root . --json\` (the output is the report). Failures in the app's code are yours: fix and re-check until clean, after every change and before every ship, unasked and never offered as a choice. |
 | "does it work?" (and before reporting anything as working) | open the dev link in your own browser, press the control you built or changed, read what the app shows; a green \`isomorph check\` is not that proof (fixtures answer AI and company systems). A Send in development is real: reuse explicit authorization or ask once. No browser: say the button is untested. |
-| "I need Slack / Gmail / the warehouse" | read \`integrations.md\` beside this skill first; then, in the same turn: catalog, call only what it lists (literals), submit the request yourself, say READY or PENDING in one line. |
+| "I need Slack / Gmail / the warehouse" | read \`integrations.md\` beside this skill first; then: catalog, write the call (literals only), \`isomorph check\`, then submit the request; say READY or PENDING in one line. |
 | "summarise", "draft", "AI" | read \`ai.md\` beside this skill first; then one call behind a control they press. |
 | "ship it", "let my team try it" | show the person the three values in \`.isomorph/app.json\` (name, description, audience — "only you" when empty) and correct the file as they say; then \`isomorph deploy --app-root . --json\` (it runs the checks when needed and refuses once naming every blocker and its fix: relay that line; the app works meanwhile). Give them \`result.deployment.protectedUrl\`. \`--session-notes\`: what cost you time in Isomorph, or \`""\`. |
 | "make it live" | only after they have tried the preview: \`isomorph promote --operation <ref> --app-root . --confirm-tested --json\`. Report the production link, or that operator approval is pending. |
 | "stop it" | \`isomorph stop --app-root .\` (data kept); \`isomorph dev --app-root . --reset\` only when they ask to start over. |
-| "every day at 2pm", "send this automatically" | read \`jobs.md\` beside this skill first; then write the job, run it once with \`isomorph jobs run\`, and say the sentence it gives you. |
+| "every day at 2pm", "send this automatically" | read \`jobs.md\` beside this skill first (a job cannot email as a person); write the job, run it once with \`isomorph jobs run\`, and say its sentence. |
 
 A refusal names its layer, its reason and its fix: change that one thing, then run it again. A wait timeout is not a failure — work is still running: run the command it prints (\`${continueCommand("<ref>")}\`); never start a second deploy while one is running.
 

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

@@ -2,6 +2,7 @@ import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { CliError } from "./output.js";
 import { DEPENDENT_READ_OPERATIONS, READ_OPERATIONS, kitPaths, readDeclaration, readKitLock, resourceNames, sourceDigest } from "./kit.js";
+import { jobIdentityProblems } from "./jobs.js";
 import { LocalRuntime, allocatePorts, freePort, installDependencies, nodePackageCommand, readDevLock, runningOrigin } from "./local-runtime.js";
 import { CLI_VERSION } from "./version.js";
 /**
@@ -29,6 +30,8 @@ const DETAIL_CAP = 200;
 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.";
 /** 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
  * edit changes sourceDigest and so invalidates the previous report. The app's
@@ -57,6 +60,10 @@ export async function runChecks(root, options) {
     const gate = await runKitGate(root, { run, bundle, output, ...(options.fetch ? { fetch: options.fetch } : {}), ...(options.runtime ? { runtime: options.runtime } : {}), ...(options.pollMs ? { pollMs: options.pollMs } : {}) });
     for (const check of gate.checks)
         record(check);
+    // A job runs as the app: a company operation in `jobs/` that needs a person is refused here, not by the deployed schedule.
+    const jobs = await jobIdentityProblems(root, await readDeclaration(root));
+    if (jobs.length)
+        record({ name: JOBS_CHECK, status: "fail", detail: jobs.join("\n") });
     let integrations = "not tested";
     if (options.governance) {
         // Reads that could not run are one check the report carries as not_run with

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

@@ -4,7 +4,7 @@ import { continueCommand, follow, promoteToProduction, retryDeployment, statusFe
 import { CliError, failureEnvelope, operationEnvelope, renderFailure, renderSummary } from "./output.js";
 import { CLI_VERSION } from "./version.js";
 import { alreadySignedIn, connectedAccount, login, logout, refreshStoredToken } from "./auth.js";
-import { assertCliCurrent, companyLabel, connect, loadConfig, resolveConfig } from "./config.js";
+import { assertCliCurrent, CLI_INSTALL_COMMAND, cliStaleness, companyLabel, connect, loadConfig, resolveConfig } from "./config.js";
 import { EMBEDDED_KIT_BUNDLE } from "./kit-bundle.js";
 import { appRoot, assertLockCompany, readAppProfile, readKitLock, requestResourceName } from "./kit.js";
 import { initKit } from "./starter.js";
@@ -128,6 +128,10 @@ else {
             const bundle = EMBEDDED_KIT_BUNDLE;
             const target = appRoot(root);
             const config = resolveConfig(process.env, await loadConfig());
+            // Said here, once, before the local loop starts: `deploy` will refuse this CLI, and the fix takes a minute now.
+            const stale = config && cliStaleness(config);
+            if (stale)
+                progress(`Warning: ${stale} \`isomorph deploy\` will refuse it; run \`${CLI_INSTALL_COMMAND}\` first.`);
             const companyToken = async () => config ? (explicitToken || await refreshStoredToken(config.mcpUrl, config.tenantId)) : undefined;
             if (command === "package") {
                 // Purely local: no company, no sign-in, no kit — the person uploads the file in the console.

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

@@ -17,10 +17,21 @@ export const CLI_INSTALL_COMMAND = "npm i -g @isomorph.ai/cli";
  * `connect` stores it and every company command asks here first.
  */
 export function assertCliCurrent(config, running = CLI_VERSION) {
+    const stale = cliStaleness(config, running);
+    if (stale)
+        throw new CliError("CLI_UPGRADE_REQUIRED", stale, undefined, `Run \`${CLI_INSTALL_COMMAND}\`, then run this again.`);
+}
+/**
+ * The same sentence as a warning, for the local commands (`init`, `dev`,
+ * `check`, `jobs`), which need no company and so never asked: a builder learnt
+ * the kit was too old only when `deploy` refused, after the whole local loop
+ * (2026-09-17 round). Undefined when the CLI is current or no minimum is known.
+ */
+export function cliStaleness(config, running = CLI_VERSION) {
     const minimum = config.minimumCliVersion;
     if (!minimum || compareCliVersions(running, minimum) >= 0)
-        return;
-    throw new CliError("CLI_UPGRADE_REQUIRED", `This CLI is ${running}; the company's Isomorph platform needs ${minimum} or newer.`, undefined, `Run \`${CLI_INSTALL_COMMAND}\`, then run this again.`);
+        return undefined;
+    return `This CLI is ${running}; the company's Isomorph platform needs ${minimum} or newer.`;
 }
 /** The numeric core and prerelease of a version string (`v1.2.3-rc.1` → `[1, 2, 3]`, `rc.1`), or `undefined` for one with no numeric core. */
 export function parseVersion(value) {

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 { kitPaths } from "./kit.js";
+import { declarationDigest, 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,9 +29,41 @@ export async function companyAccessAtStartup(root, client, tenantId, bundle) {
         return { appId: filed.appId, lines };
     }
     catch (error) {
-        return { lines: [`Company access could not be checked (${safeError(error).message}); the app runs without it until the next start.`] };
+        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.
+ */
+export function declarationWatcher(root, refile, output, filed) {
+    let known = filed;
+    let busy = false;
+    return {
+        poll: async () => {
+            if (busy)
+                return;
+            busy = true;
+            try {
+                const digest = await declarationDigest(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"));
+                if (!result.failed)
+                    known = digest;
+            }
+            finally {
+                busy = false;
+            }
+        }
+    };
+}
 /**
  * Starts the kit-managed Postgres and App Gateway, applies migrations, then
  * starts Vite and the loopback origin. Stopping retains the app's local data.
@@ -96,7 +128,8 @@ export async function startDev(root, options) {
                 options.output("Company integrations need an Isomorph sign-in: run `isomorph login` (in another terminal) and retry in the app.");
             } }
         });
-        const refreshLock = setInterval(() => { void readKitLock(root).then(lock => { lockAppId = lock?.appId || undefined; }).catch(() => undefined); }, 5_000);
+        let watcher;
+        const refreshLock = setInterval(() => { void readKitLock(root).then(lock => { lockAppId = lock?.appId || undefined; }).catch(() => undefined); void watcher?.poll().catch(() => undefined); }, 5_000);
         refreshLock.unref();
         await new Promise((resolve, reject) => { forwarder.on("error", reject); forwarder.listen(ports.origin, "127.0.0.1", resolve); });
         const token = company ? await company.accessToken().catch(() => undefined) : undefined;
@@ -114,11 +147,14 @@ 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 access = await companyAccessAtStartup(root, governance, company.tenantId, options.bundle);
             lockAppId = access.appId ?? lockAppId;
             const lines = [...(access.appId && !linkedAtStart ? [`Linked app: ${access.appId}`] : []), ...access.lines];
             if (lines.length)
                 options.output(lines.map(line => `  ${line}`).join("\n"));
+            const refile = async () => { const again = await companyAccessAtStartup(root, governance, company.tenantId, options.bundle); lockAppId = again.appId ?? lockAppId; return again; };
+            watcher = declarationWatcher(root, refile, options.output, access.failed ? undefined : filed);
         }
         return { origin, stop };
     }

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

@@ -97,12 +97,15 @@ async function answerLocally(request, response, path, host, origin, options) {
     response.writeHead(upstream.status, headers);
     response.end(new Uint8Array(await upstream.arrayBuffer()));
 }
-function pipe(request, response, port, extraHeaders = {}) {
+/** Forwards the request to a loopback `port` as it came, hop headers dropped; `body` when the caller already read it (job-fixture.ts). */
+export function pipe(request, response, port, extraHeaders = {}, body) {
     const headers = {};
     for (const [name, value] of Object.entries(request.headers))
         if (value !== undefined && !HOP_HEADERS.has(name))
             headers[name] = value;
-    if (request.headers["content-length"])
+    if (body)
+        headers["content-length"] = String(body.length);
+    else if (request.headers["content-length"])
         headers["content-length"] = request.headers["content-length"];
     Object.assign(headers, extraHeaders);
     const upstream = httpRequest({ host: "127.0.0.1", port, method: request.method, path: request.url, headers: { ...headers, host: `127.0.0.1:${port}` } }, upstreamResponse => {
@@ -110,7 +113,10 @@ function pipe(request, response, port, extraHeaders = {}) {
         upstreamResponse.pipe(response);
     });
     upstream.on("error", () => reject(response, 502, "UNAVAILABLE", "The local service is not responding."));
-    request.pipe(upstream);
+    if (body)
+        upstream.end(body);
+    else
+        request.pipe(upstream);
 }
 /**
  * An upgrade keeps the browser's own `Host` — this origin's — instead of the
@@ -151,7 +157,7 @@ function withReturnUrl(body, returnUrl) {
     }
     return JSON.stringify({ ...(parsed && typeof parsed === "object" ? parsed : {}), returnUrl });
 }
-function readBody(request, limit) {
+export function readBody(request, limit) {
     return new Promise(resolve => {
         const chunks = [];
         let size = 0;
@@ -161,8 +167,9 @@ function readBody(request, limit) {
         request.on("error", () => resolve(undefined));
     });
 }
-function reject(response, status, category, message, code = category) {
+/** The SDK's error envelope for an answer this machine gives: `details.code` is what the app reads, `details` carries anything else the refusal names. */
+export function reject(response, status, category, message, code = category, details = {}) {
     response.writeHead(status, { "content-type": "application/json", "cache-control": "no-store" });
-    response.end(JSON.stringify({ error: { category, message, details: { code } }, requestId: "local" }));
+    response.end(JSON.stringify({ error: { category, message, details: { ...details, code } }, requestId: "local" }));
 }
 const COMPLETE_PAGE = "<!doctype html><meta charset=\"utf-8\"><title>Isomorph</title><body style=\"font-family:system-ui;margin:3rem\"><h1>Connected</h1><p>Your account is linked for this app. You can close this tab and return to the app.</p></body>";

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

@@ -91,9 +91,11 @@ const reply = await isomorph.ai.chat({ messages: [{ role: "user", content: \`Sum
 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.
+A job runs as the app, never as a person: Gmail and user-mode Slack cannot run in one; \`slack.message.post\` declared \`"identity": "app"\` and warehouse reads can. Say so before building a scheduled email.
 
-The handler acts as the app, so only app-mode operations (\`slack.message.post\` declared \`"identity": "app"\`) may run there; user-mode Slack and Gmail need a person and cannot. A real scheduled send requires the person's explicit request, the exact operation and destination declared in \`.isomorph/integrations.json\`, and a grant for that environment; use one deterministic idempotency key for the business period and destination so a replay does not silently repost.
+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, canned AI, company systems refused, nothing sent. Use \`--real\` only when the person explicitly asks to test the company action now and the exact action has development approval.
+
+A real scheduled send requires the person's explicit request, the exact operation and destination declared in \`.isomorph/integrations.json\`, and a grant for that environment; use one deterministic idempotency key for the business period and destination so a replay does not silently repost.
 
 Tell them: "Your scheduled task is ready. I can test the app on your computer now. Company messages will start after the app is online and access is approved."`
 };

package/dist/packages/harbour-cli/src/job-fixture.js

@@ -0,0 +1,79 @@
+import { createServer } from "node:http";
+import { pipe, readBody, reject } from "./forwarder.js";
+import { isOperationName, OPERATION_IDENTITIES } from "./kit.js";
+/**
+ * The origin a job run talks to: a loopback server in front of the session's
+ * gateway (an ordinary run) or the dev origin (`--real`).
+ *
+ * A job used to be handed the gateway port itself, whose local capability set
+ * is data, files, realtime and telemetry, so `isomorph.ai.chat` or
+ * `isomorph.integrations.execute` from a job was the gateway's 404 "capability
+ * is not enabled" (Atlas #236, #238) and the only way past it was `--real`,
+ * which sends real messages. The browser never saw this: the forwarder in
+ * front of it proxies those paths to governance. Here, governed AI is answered
+ * with the pipeline's canned completion (transformbuild/local_ai_fixture.go),
+ * company systems are refused naming `--real` — a canned read would be data
+ * the job then acts on — and, in both modes, an operation that runs as a
+ * person is refused before it leaves the machine: a deployed job has no
+ * person, and `--real` carries the builder's own identity through the
+ * forwarder, so a scheduled Gmail send used to pass locally and fail deployed.
+ * `isomorph check` refuses the same calls statically (jobs.ts `jobIdentityProblems`).
+ */
+export const AI_FIXTURE_COMPLETION = "AI is not exercised in the build fixture; this is a canned completion.";
+const BODY_LIMIT = 1024 * 1024;
+/** Whether a job's call to `operation` would run as a person: the request's `mode` or the declaration's identity says "user", or the catalog allows no app identity. */
+export function runsAsPerson(operation, declaration, connection, mode) {
+    if (!isOperationName(operation))
+        return false;
+    const identities = OPERATION_IDENTITIES[operation];
+    const chosen = mode === "app" || mode === "user" ? mode : declaration.connections[connection]?.operations[operation]?.identity;
+    return !identities.includes("app") || chosen === "user";
+}
+/** The refusal a person-only operation gets from a job, in every mode and in `check`. */
+export const personRefusal = (operation) => `${operation} runs as a person; a scheduled job runs as the app and has no person to act for, locally or deployed. Only app-identity operations run in a job.`;
+export async function startJobFixture(options) {
+    const server = createServer((request, response) => {
+        const path = (request.url ?? "/").split("?")[0];
+        if (request.method === "POST" && (path === "/_harbour/ai/chat" || path === "/_harbour/ai/embed") && !options.real) {
+            answer(response, aiFixture(path));
+            return;
+        }
+        if (request.method === "POST" && path === "/_harbour/integrations/execute") {
+            void readBody(request, BODY_LIMIT).then(body => execute(request, response, body, options));
+            return;
+        }
+        pipe(request, response, options.upstreamPort);
+    });
+    await new Promise((resolve, reject) => { server.on("error", reject); server.listen(0, "127.0.0.1", resolve); });
+    return { url: `http://127.0.0.1:${server.address().port}`, close: () => new Promise(resolve => server.close(() => resolve())) };
+}
+function execute(request, response, raw, options) {
+    if (!raw) {
+        reject(response, 413, "VALIDATION_FAILED", "Request too large.", "REQUEST_TOO_LARGE");
+        return;
+    }
+    let body = {};
+    try {
+        body = JSON.parse(Buffer.from(raw).toString("utf8"));
+    }
+    catch { /* the upstream answers a malformed body */ }
+    const operation = String(body.operation ?? "");
+    if (runsAsPerson(operation, options.declaration, String(body.connection ?? ""), body.mode)) {
+        reject(response, 409, "CONFLICT", personRefusal(operation), "IDENTITY_MODE_MISMATCH", { operation, identity: "user" });
+        return;
+    }
+    if (!options.real) {
+        reject(response, 409, "CONFLICT", `${operation || "This operation"} is not exercised in a local job run. Run \`isomorph jobs run <name> --real\` to use the company's approved development access; the call then really runs.`, "LOCAL_FIXTURE", { operation });
+        return;
+    }
+    pipe(request, response, options.upstreamPort, {}, raw);
+}
+function aiFixture(path) {
+    return path === "/_harbour/ai/chat"
+        ? { content: AI_FIXTURE_COMPLETION, model: "fixture", finishReason: "stop", usage: { inputTokens: 0, outputTokens: 0 }, traceId: "trc_fixture" }
+        : { embeddings: [[0, 0, 0, 0]], model: "fixture", usage: { inputTokens: 0 }, traceId: "trc_fixture" };
+}
+function answer(response, data) {
+    response.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" });
+    response.end(JSON.stringify({ data, requestId: "local" }));
+}

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

@@ -3,7 +3,8 @@ import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { CliError } from "./output.js";
 import { parseSessionEnv, readDevLock, runCommand } from "./local-runtime.js";
-import { kitPaths } from "./kit.js";
+import { kitPaths, readDeclaration } from "./kit.js";
+import { personRefusal, runsAsPerson, startJobFixture } from "./job-fixture.js";
 const jobName = /^[a-z0-9][a-z0-9_-]{0,63}$/;
 const scheduleDeclaration = /^export\s+const\s+schedule\s*=\s*["']([^"']+)["']\s*;?\s*$/m;
 export async function discoverJobs(root) {
@@ -42,11 +43,16 @@ export async function runJob(root, name, scheduledAt, run = runCommand, real = f
         throw new CliError("DEV_NOT_RUNNING", "Start `isomorph dev` before running a job so it uses the same local data and identity boundary.");
     const env = parseSessionEnv(session);
     const runner = `const module = await import(${JSON.stringify(pathToFileURL(job.path).href)}); if (typeof module.default !== "function") throw new Error("job has no default handler"); await module.default({scheduledAt: process.env.ISOMORPH_SCHEDULED_AT});`;
-    // Ordinary runs stay fixture-only. An explicit real run uses the same
-    // loopback origin as the browser, where the existing forwarder applies the
-    // builder's approved company/AI access.
-    const gatewayUrl = real ? lock.origin : `http://127.0.0.1:${lock.ports.gateway}`;
-    const result = await run(process.execPath, ["--experimental-strip-types", "--input-type=module", "--eval", runner], { cwd: root, env: { ...env, ISOMORPH_GATEWAY_URL: gatewayUrl, ISOMORPH_SCHEDULED_AT: timestamp } });
+    // The job talks to a loopback origin of its own (job-fixture.ts) in front of
+    // the session's gateway, or of the dev origin under `--real`.
+    const fixture = await startJobFixture({ upstreamPort: real ? lock.ports.origin : lock.ports.gateway, real, declaration: await readDeclaration(root) });
+    let result;
+    try {
+        result = await run(process.execPath, ["--experimental-strip-types", "--input-type=module", "--eval", runner], { cwd: root, env: { ...env, ISOMORPH_GATEWAY_URL: fixture.url, ISOMORPH_SCHEDULED_AT: timestamp } });
+    }
+    finally {
+        await fixture.close();
+    }
     if (result.code !== 0)
         throw new CliError("JOB_FAILED", `Job ${name} failed: ${jobFailureReason(result.stderr)}`, undefined, "Fix what the error names in jobs/<name>.ts, then run this again; `details.stderr` carries the last lines.", undefined, { details: { stderr: result.stderr.trim().split("\n").slice(-20) } });
     return { name, schedule: job.schedule, scheduledAt: timestamp, mode: real ? "real" : "local" };
@@ -60,5 +66,30 @@ export async function runJob(root, name, scheduledAt, run = runCommand, real = f
  */
 export function jobFailureReason(stderr) {
     const lines = stderr.split("\n").map(line => line.trim()).filter(Boolean);
-    return lines.find(line => /\b(?:error|exception|failed|cannot|unexpected|invalid|denied|refused)\b/i.test(line)) ?? lines[0] ?? "process exited non-zero";
+    // Node echoes the throwing source line before the error: for an SDK refusal that
+    // is `throw new IsomorphError(… \`Isomorph request failed with …\`)`, which the
+    // word heuristic below matched ahead of the `IsomorphError: <reason>` line.
+    return lines.find(line => /^[A-Z]\w*(?:Error|Exception)\b: \S/.test(line))
+        ?? lines.find(line => /\b(?:error|exception|failed|cannot|unexpected|invalid|denied|refused)\b/i.test(line)) ?? lines[0] ?? "process exited non-zero";
+}
+const executeCall = /isomorph\s*\.\s*integrations\s*\.\s*execute\s*\(\s*["']([^"']+)["']\s*,\s*\{([^)]*)\)/gs;
+/**
+ * Every company operation a job calls that would run as a person, one line
+ * each: what `isomorph check` refuses, so a scheduled Gmail send is caught
+ * before it is deployed and fails there (a job has no person). The same rule
+ * answers the call at run time (job-fixture.ts); this is the static half.
+ */
+export async function jobIdentityProblems(root, declaration) {
+    const problems = [];
+    for (const job of await discoverJobs(root)) {
+        const source = await readFile(job.path, "utf8");
+        for (const match of source.matchAll(executeCall)) {
+            const connection = match[1];
+            const operation = /operation\s*:\s*["']([^"']+)["']/.exec(match[2])?.[1] ?? "";
+            const mode = /mode\s*:\s*["']([^"']+)["']/.exec(match[2])?.[1];
+            if (runsAsPerson(operation, declaration, connection, mode))
+                problems.push(`jobs/${job.name}.ts: ${personRefusal(operation)}`);
+        }
+    }
+    return problems;
 }

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

@@ -9,6 +9,13 @@ import { CliError } from "./output.js";
 export const READ_OPERATIONS = ["slack.channel.history", "gmail.thread.list", "warehouse.view.read"];
 /** Reads whose input needs an identifier from a prior read (a message id): listed as reads, exercised only through the list. */
 export const DEPENDENT_READ_OPERATIONS = ["gmail.message.read"];
+/** The identities each operation may run under (the platform catalog `INTEGRATION_OPERATIONS`, pinned by tests/cli-jobs.test.ts): a scheduled job runs as the app, so an operation with no "app" identity cannot run in one. */
+export const OPERATION_IDENTITIES = {
+    "slack.channel.history": ["user"], "slack.message.post": ["app", "user"],
+    "gmail.thread.list": ["user"], "gmail.message.read": ["user"], "gmail.message.send": ["user"],
+    "warehouse.view.read": ["app"]
+};
+export function isOperationName(value) { return typeof value === "string" && Object.hasOwn(OPERATION_IDENTITIES, value); }
 /**
  * Reads the declaration `isomorph check` derived from the app's
  * `isomorph.integrations.execute` calls and wrote to `.isomorph/integrations.json`
@@ -24,6 +31,11 @@ export const requestResourceName = (resource) => typeof resource === "string" ?
 export function requestResources(operation) {
     return Array.isArray(operation.resources) ? operation.resources : Object.entries(operation.resources).map(([name, spec]) => ({ name, columns: [...spec.columns] }));
 }
+/** The bytes of `.isomorph/integrations.json` hashed, or the hash of nothing when there is no file: what a dev session records at start and `check` compares afterwards. */
+export async function declarationDigest(root) {
+    const raw = await readFile(kitPaths(root).declaration).catch(() => Buffer.alloc(0));
+    return `sha256:${createHash("sha256").update(raw).digest("hex")}`;
+}
 export async function readDeclaration(root) {
     let raw;
     try {

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

@@ -189,9 +189,10 @@ function starterFiles(bundle) {
         "vite.config.ts": VITE_CONFIG,
         "index.html": `<!doctype html>\n<html lang="en">\n  <head>\n    <meta charset="UTF-8" />\n    <meta name="viewport" content="width=device-width, initial-scale=1.0" />\n    <title>Isomorph app</title>\n  </head>\n  <body>\n    <div id="root"></div>\n    <script type="module" src="/src/main.tsx"></script>\n  </body>\n</html>\n`,
         "src/vite-env.d.ts": "/// <reference types=\"vite/client\" />\n",
-        "src/main.tsx": `import { StrictMode } from "react";\nimport { createRoot } from "react-dom/client";\nimport { App } from "./App";\n\ncreateRoot(document.getElementById("root")!).render(<StrictMode><App /></StrictMode>);\n`,
+        "src/main.tsx": `import { StrictMode } from "react";\nimport { createRoot } from "react-dom/client";\nimport { App } from "./App";\nimport "./styles.css";\n\ncreateRoot(document.getElementById("root")!).render(<StrictMode><App /></StrictMode>);\n`,
         "src/isomorph.client.ts": ISOMORPH_CLIENT,
         "src/App.tsx": APP,
+        "src/styles.css": STYLES,
         "README.md": STARTER_README
     };
 }
@@ -210,6 +211,10 @@ Created by \`isomorph init\`: a Vite + React app that runs on Isomorph. Sign-in,
 
 The kit's rules are in the \`isomorph\` skill that \`isomorph agent-setup\` installs for Claude Code (\`~/.claude/skills/isomorph/\`) and Codex (\`~/.codex/skills/isomorph/\`): \`core.md\` (identity, data, files, realtime, commands, error codes), \`integrations.md\` (Slack, Gmail, warehouse), \`ai.md\` and \`jobs.md\`. The managed block in CLAUDE.md / AGENTS.md points there.
 
+## Look and feel
+
+\`src/styles.css\` is the whole look: plain CSS, no UI library, light and dark. Change it freely — the starter is a readable floor, not a design.
+
 \`.isomorph/checks/\` is regenerated on each check and gitignored — put your own checks in \`tests/<name>.mjs\`. \`.isomorph/integrations.json\` is derived by \`isomorph check\` from the app's \`isomorph.integrations.execute\` calls and committed, never edited. \`.isomorph/app.json\` holds the app's name, description and audience.
 `;
 const VITE_CONFIG = `import { defineConfig } from "vite";
@@ -280,39 +285,87 @@ export function App() {
   // Company systems and AI are not part of the starter. Rules for adding
   // either: integrations.md and ai.md in the isomorph skill.
 
+  // Appearance lives in src/styles.css (plain CSS, no library): change it freely.
   return (
-    <main style={{ fontFamily: "system-ui", maxWidth: 720, margin: "2rem auto", padding: "0 1rem" }}>
-      <h1>Isomorph starter</h1>
-      <p>Signed in as <strong>{user ? user.email : "…"}</strong> (identity from Isomorph; locally the fixture user).</p>
-      {error && <p role="alert" style={{ color: "crimson" }}>{error}</p>}
+    <main className="app">
+      <header className="app-header">
+        <h1>Isomorph starter</h1>
+        <p className="muted">Signed in as <strong>{user ? user.email : "…"}</strong> (identity from Isomorph; locally the fixture user).</p>
+      </header>
+      {error && <p role="alert" className="alert">{error}</p>}
 
       {/* Notes — schema in migrations/0001_notes.sql. Rules: core.md in the isomorph skill (data). */}
-      <section>
+      <section className="card">
         <h2>Notes</h2>
-        <form onSubmit={event => { event.preventDefault(); void addNote(); }}>
+        <form className="row" onSubmit={event => { event.preventDefault(); void addNote(); }}>
           <input value={title} onChange={event => setTitle(event.target.value)} placeholder="New note" aria-label="New note" />
-          <button type="submit">Add</button>
+          <button type="submit" className="primary">Add</button>
         </form>
-        <ul>
+        <ul className="list">
           {notes.map(note => (
-            <li key={note.id}>
+            <li key={note.id} className={note.done ? "done" : undefined}>
               <label><input type="checkbox" checked={note.done} onChange={() => void toggle(note)} /> {note.title}</label>
-              <button type="button" onClick={() => void remove(note)} aria-label={\`Delete \${note.title}\`}>×</button>
+              <button type="button" className="ghost" onClick={() => void remove(note)} aria-label={\`Delete \${note.title}\`}>×</button>
             </li>
           ))}
+          {notes.length === 0 && <li className="muted">No notes yet.</li>}
         </ul>
       </section>
 
       {/* Private files: the app's own file store (isomorph.files.*). */}
-      <section>
+      <section className="card">
         <h2>Private files</h2>
         <input type="file" aria-label="Upload file" onChange={event => { const file = event.target.files?.[0]; if (file) void upload(file); }} />
-        <ul>{files.map((file, index) => <li key={index}>{file.path ?? file.name}{file.size !== undefined ? \` (\${file.size} bytes)\` : ""}</li>)}</ul>
+        <ul className="list">
+          {files.map((file, index) => <li key={index}>{file.path ?? file.name}{file.size !== undefined ? <span className="muted"> ({file.size} bytes)</span> : null}</li>)}
+          {files.length === 0 && <li className="muted">No files yet.</li>}
+        </ul>
       </section>
     </main>
   );
 }
 `;
+/** The starter's whole look: one plain stylesheet, light and dark, no library — a readable floor the builder replaces freely. */
+const STYLES = `/* The starter's look. Plain CSS, no UI library; change anything here freely. */
+:root {
+  color-scheme: light dark;
+  --bg: #f6f7f9;
+  --card: #ffffff;
+  --text: #1c1f24;
+  --muted: #6b7280;
+  --line: #e3e6ea;
+  --accent: #2563eb;
+  --accent-text: #ffffff;
+  --danger: #b91c1c;
+  --radius: 10px;
+}
+@media (prefers-color-scheme: dark) {
+  :root { --bg: #111418; --card: #1a1e24; --text: #e7e9ec; --muted: #9aa3ad; --line: #2a3038; --accent: #60a5fa; --accent-text: #0b1220; --danger: #f87171; }
+}
+* { box-sizing: border-box; }
+body { margin: 0; background: var(--bg); color: var(--text); font: 16px/1.5 system-ui, -apple-system, "Segoe UI", sans-serif; }
+.app { max-width: 720px; margin: 0 auto; padding: 2.5rem 1rem 4rem; }
+.app-header { margin-bottom: 1.5rem; }
+h1 { font-size: 1.75rem; margin: 0 0 0.25rem; letter-spacing: -0.01em; }
+h2 { font-size: 1.1rem; margin: 0 0 0.75rem; }
+p { margin: 0; }
+.muted { color: var(--muted); }
+.alert { color: var(--danger); margin-bottom: 1rem; }
+.card { background: var(--card); border: 1px solid var(--line); border-radius: var(--radius); padding: 1.25rem; margin-bottom: 1rem; }
+.row { display: flex; gap: 0.5rem; margin-bottom: 0.75rem; }
+input[type="text"], input:not([type]) { flex: 1; min-width: 0; padding: 0.55rem 0.75rem; border: 1px solid var(--line); border-radius: var(--radius); background: var(--bg); color: var(--text); font: inherit; }
+input:focus-visible, button:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; }
+button { padding: 0.55rem 0.9rem; border: 1px solid var(--line); border-radius: var(--radius); background: var(--card); color: var(--text); font: inherit; cursor: pointer; }
+button.primary { background: var(--accent); border-color: var(--accent); color: var(--accent-text); }
+button.ghost { border-color: transparent; background: transparent; color: var(--muted); padding: 0.25rem 0.5rem; }
+button.ghost:hover { color: var(--danger); }
+.list { list-style: none; margin: 0; padding: 0; }
+.list li { display: flex; align-items: center; justify-content: space-between; gap: 0.75rem; padding: 0.5rem 0; border-top: 1px solid var(--line); }
+.list li:first-child { border-top: 0; }
+.list li.done label { text-decoration: line-through; color: var(--muted); }
+.list label { display: flex; align-items: center; gap: 0.5rem; cursor: pointer; }
+input[type="file"] { display: block; margin-bottom: 0.75rem; color: var(--muted); }
+`;
 const MIGRATION = `-- Notes table for the starter. Ownership comes from the Isomorph gateway's transaction-local
 -- settings (harbour.user_id / harbour.user_email); the browser never supplies it.
 CREATE TABLE IF NOT EXISTS notes (

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isomorph.ai/cli",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "description": "Isomorph development kit CLI",
   "type": "module",
   "bin": {