orizu 0.5.51 → 0.5.53

package/dist/egress-allowlist-cli.js

@@ -9,19 +9,16 @@
  * The BASE allowlist (Orizu API + model provider + git host) is code-owned and
  * NOT shown/managed here — this surface only widens a team's egress with domains
  * a customer workflow needs. Human ADMIN only: the server rejects agent bearers
- * and non-admins (the definer RPC gates on is_team_admin). Pure command logic
- * with an injected fetcher.
+ * and non-admins (the definer RPC gates on is_team_admin). The arguments and
+ * output live here; the requests run on Effect in egress-allowlist-workflow.ts
+ * (ORI-2764), loaded only when this command runs.
  */
-import { authedFetch } from './http.js';
 /** Mirrors MAX_TEAM_EGRESS_DOMAINS in the shared read-side validator
  *  (workers/session-coordinator/src/egress-domains.ts). The coordinator only
  *  applies the first this-many UNIQUE valid domains at policy compose; the
  *  CLI is a standalone package and cannot import the worker module, so the
  *  cap constant is duplicated here (kept in sync via that file's tests). */
 const MAX_ADDITIVE_EGRESS_DOMAINS = 100;
-function fetcherFrom(io) {
-    return io.fetcher ?? authedFetch;
-}
 function argValue(args, flag) {
     const index = args.indexOf(flag);
     if (index === -1 || index + 1 >= args.length || args[index + 1].startsWith('--')) {
@@ -45,23 +42,13 @@ function printErr(io, message) {
     ;
     (io.printErr ?? io.print)(message);
 }
-async function responseMessage(response) {
-    try {
-        const data = (await response.clone().json());
-        const error = typeof data.error === 'string' ? data.error : null;
-        return error || response.statusText || String(response.status);
-    }
-    catch {
-        return response.statusText || String(response.status);
-    }
-}
-function splitDomains(value) {
+export function splitDomains(value) {
     return value
         .split(',')
         .map(d => d.trim())
         .filter(d => d.length > 0);
 }
-function stringArray(value) {
+export function stringArray(value) {
     return Array.isArray(value) ? value.filter((d) => typeof d === 'string') : [];
 }
 /**
@@ -75,7 +62,7 @@ function stringArray(value) {
  * shrink-by-one on an oversized legacy row leaves the returned set still
  * over-cap and the server does not send cappedDomains back.
  */
-function deriveCapped(stored, invalid) {
+export function deriveCapped(stored, invalid) {
     const invalidSet = new Set(invalid);
     const capped = [];
     let validCount = 0;
@@ -88,19 +75,7 @@ function deriveCapped(stored, invalid) {
     }
     return capped;
 }
-async function fetchCurrent(fetcher, path) {
-    const response = await fetcher(path, { method: 'GET' });
-    if (!response.ok) {
-        throw new Error(`show failed (${response.status}): ${await responseMessage(response)}`);
-    }
-    const data = (await response.json());
-    return {
-        domains: stringArray(data.extraDomains),
-        invalid: stringArray(data.invalidDomains),
-        capped: stringArray(data.cappedDomains),
-    };
-}
-function emit(io, teamSlug, current) {
+export function emit(io, teamSlug, current) {
     if (io.json) {
         io.print(JSON.stringify({
             teamSlug,
@@ -134,61 +109,13 @@ export async function egressAllowlistCommand(args, io) {
         printErr(io, 'Usage: orizu team egress-allowlist <team> [--add <domain>|--remove <domain>|--set a.com,b.com|--clear] [--json]');
         return 1;
     }
-    const path = `/api/cli/teams/${encodeURIComponent(teamSlug)}/egress-allowlist`;
-    const fetcher = fetcherFrom(io);
-    const setValue = argValue(args, '--set');
-    const addValue = argValue(args, '--add');
-    const removeValue = argValue(args, '--remove');
-    const clear = args.includes('--clear');
-    const isMutation = setValue !== null || addValue !== null || removeValue !== null || clear;
-    try {
-        if (!isMutation) {
-            emit(io, teamSlug, await fetchCurrent(fetcher, path));
-            return 0;
-        }
-        // Compute the next set. --set/--clear replace; --add/--remove mutate current.
-        let next;
-        if (setValue !== null) {
-            next = splitDomains(setValue);
-        }
-        else if (clear) {
-            next = [];
-        }
-        else {
-            const current = await fetchCurrent(fetcher, path);
-            const set = new Set(current.domains);
-            if (addValue)
-                for (const d of splitDomains(addValue))
-                    set.add(d);
-            if (removeValue)
-                for (const d of splitDomains(removeValue))
-                    set.delete(d);
-            next = [...set];
-        }
-        const response = await fetcher(path, {
-            method: 'PUT',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ domains: next }),
-        });
-        if (!response.ok) {
-            printErr(io, `egress-allowlist update failed (${response.status}): ${await responseMessage(response)}`);
-            return 1;
-        }
-        const data = (await response.json());
-        const stored = Array.isArray(data.extraDomains) ? stringArray(data.extraDomains) : next;
-        const invalid = stringArray(data.invalidDomains);
-        // Grandfathered retention: a successful PUT may still STORE legacy
-        // invalid entries the admin retained — the server flags them and we show
-        // it. Round 5 (P2): a >100-entry legacy row can only shrink one entry per
-        // PUT (the write RPC's GREATEST(100, stored-1) bound), so the returned
-        // set can still be OVER the cap. Re-derive the cap annotations from the
-        // returned set — same positional logic GET uses — instead of assuming
-        // the RPC left it at/under 100.
-        emit(io, teamSlug, { domains: stored, invalid, capped: deriveCapped(stored, invalid) });
-        return 0;
-    }
-    catch (error) {
-        printErr(io, error instanceof Error ? error.message : String(error));
-        return 1;
-    }
+    const { runEgressAllowlist } = await import('./egress-allowlist-workflow.js');
+    return await runEgressAllowlist({
+        teamSlug,
+        path: `/api/cli/teams/${encodeURIComponent(teamSlug)}/egress-allowlist`,
+        setValue: argValue(args, '--set'),
+        addValue: argValue(args, '--add'),
+        removeValue: argValue(args, '--remove'),
+        clear: args.includes('--clear'),
+    }, io);
 }

package/dist/egress-allowlist-workflow.d.ts

@@ -0,0 +1,17 @@
+import { type EgressAllowlistCommandIo } from './egress-allowlist-cli.js';
+/** What one run does: show the list, or change it. */
+export interface EgressAllowlistRun {
+    teamSlug: string;
+    path: string;
+    setValue: string | null;
+    addValue: string | null;
+    removeValue: string | null;
+    clear: boolean;
+}
+/**
+ * Runs one `orizu team egress-allowlist` command to its exit code. Ctrl-C or
+ * SIGTERM ends the wait with 130 or 143; once the PUT was sent the person is
+ * told the update may be saved.
+ */
+export declare function runEgressAllowlist(run: EgressAllowlistRun, io: EgressAllowlistCommandIo): Promise<number>;
+//# sourceMappingURL=egress-allowlist-workflow.d.ts.map

package/dist/egress-allowlist-workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"egress-allowlist-workflow.d.ts","sourceRoot":"","sources":["../src/egress-allowlist-workflow.ts"],"names":[],"mappings":"AAaA,OAAO,EAML,KAAK,wBAAwB,EAE9B,MAAM,2BAA2B,CAAA;AAoFlC,sDAAsD;AACtD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,KAAK,EAAE,OAAO,CAAA;CACf;AAkDD;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,kBAAkB,EAAE,EAAE,EAAE,wBAAwB,GAAG,OAAO,CAAC,MAAM,CAAC,CA6B/G"}

package/dist/egress-allowlist-workflow.js

@@ -0,0 +1,183 @@
+// ORI-2764 (ORI-2735c): `orizu team egress-allowlist` on Effect. Loaded only
+// through `await import(...)` from egress-allowlist-cli.ts, so other commands
+// never load Effect.
+//
+// - Each request has the dataset-transfer deadline (120 s by default).
+// - The PUT is the only write. Once it was sent, a lost or late reply may
+//   still be saved. Every change is safe to repeat (`--set`/`--clear` replace
+//   the list, `--add`/`--remove` read it again first), so the CLI says
+//   running the same command again is safe.
+// - Ctrl-C and SIGTERM stop a wait with 130 and 143.
+import { Cause, Effect, Exit } from 'effect';
+import { datasetTransferTimeoutMs } from './dataset-transfer-policy.js';
+import { deriveCapped, emit, splitDomains, stringArray, } from './egress-allowlist-cli.js';
+import { authedFetch } from './http.js';
+import { mayAlreadyBeSavedLine } from './one-request-write.js';
+import { unreachedCode } from './request-outcome.js';
+const MAY_BE = mayAlreadyBeSavedLine('egress allowlist', 'updated', 'running the same command again is safe');
+/** A failure the command prints as one message, plus the may-be line when the update may be saved. */
+class EgressFailure {
+    message;
+    mayBeSaved;
+    constructor(message, mayBeSaved = false) {
+        this.message = message;
+        this.mayBeSaved = mayBeSaved;
+    }
+}
+/** The server's `{ error }`, else the status text, else the status, as before. */
+function replyMessage(reply) {
+    try {
+        const data = JSON.parse(reply.text);
+        const error = typeof data.error === 'string' ? data.error : null;
+        return error || reply.statusText || String(reply.status);
+    }
+    catch {
+        return reply.statusText || String(reply.status);
+    }
+}
+/**
+ * One request. A deadline says so under `label`; any other failure keeps
+ * today's text. For the PUT, a failure after sending may be saved.
+ */
+function request(fetcher, path, init, label, timeoutMs, progress) {
+    return Effect.suspend(() => {
+        let sent = false;
+        let timedOut = false;
+        return Effect.tryPromise({
+            try: async (signal) => {
+                const controller = new AbortController();
+                const abort = () => controller.abort();
+                const timer = setTimeout(() => { timedOut = true; controller.abort(); }, timeoutMs);
+                if (signal.aborted)
+                    abort();
+                else
+                    signal.addEventListener('abort', abort, { once: true });
+                const markSent = () => { sent = true; if (progress)
+                    progress.putSent = true; };
+                try {
+                    const requestInit = { ...init, signal: controller.signal };
+                    const response = fetcher
+                        ? (markSent(), await fetcher(path, requestInit))
+                        : await authedFetch(path, requestInit, markSent);
+                    return { status: response.status, ok: response.ok, statusText: response.statusText, text: await response.text() };
+                }
+                finally {
+                    clearTimeout(timer);
+                    signal.removeEventListener('abort', abort);
+                    controller.abort();
+                }
+            },
+            catch: cause => {
+                const mayBeSaved = progress !== null && sent;
+                if (timedOut)
+                    return new EgressFailure(`${label}: the request exceeded its deadline`, mayBeSaved);
+                // Refused before it reached the server, or a 401 whose sign-in could not be renewed: nothing saved.
+                const refused = unreachedCode(cause) !== null || cause?.requestRejected === true;
+                return new EgressFailure(cause instanceof Error ? cause.message : String(cause), mayBeSaved && !refused);
+            },
+        });
+    });
+}
+/** A 2xx reply's JSON object; a non-JSON reply fails with the parse error, as before. */
+function parseReply(reply) {
+    return Effect.try({
+        try: () => JSON.parse(reply.text),
+        catch: cause => new EgressFailure(cause instanceof Error ? cause.message : String(cause)),
+    });
+}
+function readCurrent(fetcher, path, timeoutMs) {
+    return Effect.gen(function* () {
+        const reply = yield* request(fetcher, path, { method: 'GET' }, 'show failed', timeoutMs, null);
+        if (!reply.ok)
+            return yield* Effect.fail(new EgressFailure(`show failed (${reply.status}): ${replyMessage(reply)}`));
+        const data = yield* parseReply(reply);
+        return { domains: stringArray(data.extraDomains), invalid: stringArray(data.invalidDomains), capped: stringArray(data.cappedDomains) };
+    });
+}
+const isMutation = (run) => run.setValue !== null || run.addValue !== null || run.removeValue !== null || run.clear;
+function egressAllowlist(run, io, timeoutMs, progress) {
+    return Effect.gen(function* () {
+        if (!isMutation(run)) {
+            emit(io, run.teamSlug, yield* readCurrent(io.fetcher, run.path, timeoutMs));
+            return 0;
+        }
+        // --set/--clear replace; --add/--remove change the list read first.
+        let next;
+        if (run.setValue !== null) {
+            next = splitDomains(run.setValue);
+        }
+        else if (run.clear) {
+            next = [];
+        }
+        else {
+            const current = yield* readCurrent(io.fetcher, run.path, timeoutMs);
+            const set = new Set(current.domains);
+            if (run.addValue)
+                for (const d of splitDomains(run.addValue))
+                    set.add(d);
+            if (run.removeValue)
+                for (const d of splitDomains(run.removeValue))
+                    set.delete(d);
+            next = [...set];
+        }
+        const label = 'egress-allowlist update failed';
+        const reply = yield* request(io.fetcher, run.path, {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ domains: next }),
+        }, label, timeoutMs, progress);
+        if (!reply.ok) {
+            // A refusal (4xx) saved nothing; a 5xx after the PUT may have.
+            return yield* Effect.fail(new EgressFailure(`${label} (${reply.status}): ${replyMessage(reply)}`, reply.status >= 500));
+        }
+        const data = yield* parseReply(reply);
+        const stored = Array.isArray(data.extraDomains) ? stringArray(data.extraDomains) : next;
+        const invalid = stringArray(data.invalidDomains);
+        // Grandfathered retention: a successful PUT may still STORE legacy
+        // invalid entries the admin retained — the server flags them and we show
+        // it. Round 5 (P2): a >100-entry legacy row can only shrink one entry per
+        // PUT (the write RPC's GREATEST(100, stored-1) bound), so the returned
+        // set can still be OVER the cap. Re-derive the cap annotations from the
+        // returned set — same positional logic GET uses — instead of assuming
+        // the RPC left it at/under 100.
+        emit(io, run.teamSlug, { domains: stored, invalid, capped: deriveCapped(stored, invalid) });
+        return 0;
+    });
+}
+/**
+ * Runs one `orizu team egress-allowlist` command to its exit code. Ctrl-C or
+ * SIGTERM ends the wait with 130 or 143; once the PUT was sent the person is
+ * told the update may be saved.
+ */
+export async function runEgressAllowlist(run, io) {
+    const printErr = io.printErr ?? io.print;
+    const controller = new AbortController();
+    const progress = { putSent: false };
+    let interrupted;
+    const interrupt = () => { interrupted ??= 130; controller.abort(); };
+    const terminate = () => { interrupted ??= 143; controller.abort(); };
+    process.on('SIGINT', interrupt);
+    process.on('SIGTERM', terminate);
+    try {
+        const exit = await Effect.runPromiseExit(egressAllowlist(run, io, datasetTransferTimeoutMs(), progress), { signal: controller.signal });
+        if (Exit.isSuccess(exit))
+            return exit.value;
+        if (interrupted !== undefined) {
+            const message = isMutation(run) ? 'Egress allowlist update interrupted.' : 'Egress allowlist read interrupted.';
+            printErr(progress.putSent ? `${message}\n${MAY_BE}` : message);
+            return interrupted;
+        }
+        // Anything else that went wrong prints its message with exit 1, as before.
+        const failure = Cause.squash(exit.cause);
+        if (!(failure instanceof EgressFailure)) {
+            printErr(failure instanceof Error ? failure.message : String(failure));
+            return 1;
+        }
+        printErr(failure.mayBeSaved ? `${failure.message}\n${MAY_BE}` : failure.message);
+        return 1;
+    }
+    finally {
+        process.removeListener('SIGINT', interrupt);
+        process.removeListener('SIGTERM', terminate);
+    }
+}

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAsLA,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAA;AAEhE,eAAO,MAAM,wBAAwB,GAAI,iBAAiB,MAAM;;;EACJ,CAAA;AAE5D,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AA+sCtD,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CA0B1G;AAED,eAAO,MAAM,iBAAiB,SAAU,CAAA;AACxC,eAAO,MAAM,uBAAuB,QAAkB,CAAA;AACtD,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,UAAU,CAexH;AAmMD,wBAAsB,IAAI,CAAC,OAAO,WAAwB,iBAiiBzD;AA8DD,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAEhF,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAuLA,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAA;AAEhE,eAAO,MAAM,wBAAwB,GAAI,iBAAiB,MAAM;;;EACJ,CAAA;AAE5D,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAmqCtD,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CA0B1G;AAED,eAAO,MAAM,iBAAiB,SAAU,CAAA;AACxC,eAAO,MAAM,uBAAuB,QAAkB,CAAA;AACtD,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,UAAU,CAexH;AAmMD,wBAAsB,IAAI,CAAC,OAAO,WAAwB,iBAiiBzD;AAuED,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAEhF,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA"}

package/dist/index.js

@@ -62,7 +62,8 @@ import { killSwitchCommand } from './kill-switch-cli.js';
 import { egressAllowlistCommand } from './egress-allowlist-cli.js';
 import { teamConnectorsCommand } from './team-connectors-cli.js';
 import { inspectExistingWorkspaceTeam, getWorkspaceRoot } from './workspace.js';
-import { writeLastErrorRecord, extractLastErrorCode } from './last-error-record.js';
+import { errorOutputSecrets, writeLastErrorRecord, extractLastErrorCode } from './last-error-record.js';
+import { redactSecrets } from './secret-redaction.js';
 export { loadInstructionSet } from './instruction-set-loader.js';
 export const materializeRunnerVersion = (runnerVersionId) => materializeRegisteredRunnerVersion(runnerVersionId, false);
 export { parseJsonResponse, sanitizeTerminalText } from './json-response.js';
@@ -123,26 +124,21 @@ async function logOptimizationEvent() {
     if (!eventType || eventType.startsWith('--') || !runId || !Number.isInteger(sequence) || sequence <= 0) {
         throw new Error('Usage: orizu log <event_type> --run-id <id> --sequence <n> --payload @event.json');
     }
-    const response = await authedFetch(`/api/cli/optimization-runs/${encodeURIComponent(runId)}/events`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            eventId: getArg('--event-id') || randomUUID(),
-            sequence,
-            eventType,
-            eventLayer: getArg('--event-layer') || 'core',
-            optimizerFamily: getArg('--optimizer-family'),
-            iteration: getArg('--iteration') ? Number(getArg('--iteration')) : undefined,
-            candidateId: getArg('--candidate-id'),
-            parentCandidateId: getArg('--parent-candidate-id'),
-            childCandidateId: getArg('--child-candidate-id'),
-            payload,
-        }),
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to log event: ${await response.text()}`);
-    }
-    const data = await parseJsonResponse(response, 'Optimization event log');
+    const writes = await import('./cli-write-commands.js');
+    const data = await writes.sendCommandWrite(writes.optimizationEvent(runId, {
+        eventId: getArg('--event-id') || randomUUID(),
+        sequence,
+        eventType,
+        eventLayer: getArg('--event-layer') || 'core',
+        optimizerFamily: getArg('--optimizer-family'),
+        iteration: getArg('--iteration') ? Number(getArg('--iteration')) : undefined,
+        candidateId: getArg('--candidate-id'),
+        parentCandidateId: getArg('--parent-candidate-id'),
+        childCandidateId: getArg('--child-candidate-id'),
+        payload,
+    }), { json: hasJsonFlag(), print: printLine });
+    if (!data)
+        return;
     if (hasJsonFlag()) {
         printJson({ eventId: data.eventId });
         return;
@@ -822,25 +818,20 @@ async function startOptimizationRun() {
             trackedScope: 'best_candidate',
         })),
     ];
-    const response = await authedFetch(`/api/cli/optimization-runs?project=${encodeURIComponent(project)}`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            optimizerVersionId,
-            promptVersionIds,
-            judgeVersionIds,
-            scorers,
-            datasetVersionId,
-            splitSetId,
-            trainSplitName: getArg('--train-split') || undefined,
-            validationSplitName: getArg('--validation-split') || undefined,
-            metadata,
-        }),
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to start optimization run: ${await response.text()}`);
-    }
-    const data = await parseJsonResponse(response, 'Optimization run start');
+    const writes = await import('./cli-write-commands.js');
+    const data = await writes.sendCommandWrite(writes.optimizationStart(project, {
+        optimizerVersionId,
+        promptVersionIds,
+        judgeVersionIds,
+        scorers,
+        datasetVersionId,
+        splitSetId,
+        trainSplitName: getArg('--train-split') || undefined,
+        validationSplitName: getArg('--validation-split') || undefined,
+        metadata,
+    }), { json: hasJsonFlag(), print: printLine });
+    if (!data)
+        return;
     if (hasJsonFlag()) {
         printJson(data);
         return;
@@ -897,15 +888,10 @@ async function updateOptimizationRunLifecycle(action) {
             body.resultPromptVersionId = resultPromptVersionId;
         }
     }
-    const response = await authedFetch(`/api/cli/optimization-runs/${encodeURIComponent(runId)}`, {
-        method: 'PATCH',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to update optimization run: ${await response.text()}`);
-    }
-    const data = await parseJsonResponse(response, 'Optimization run update');
+    const writes = await import('./cli-write-commands.js');
+    const data = await writes.sendCommandWrite(writes.optimizationLifecycle(runId, body), { json: hasJsonFlag(), print: printLine });
+    if (!data)
+        return;
     if (hasJsonFlag()) {
         printJson(data);
         return;
@@ -1805,9 +1791,17 @@ function isCliEntrypoint() {
         return false;
     }
 }
+// A secret this process holds (a login code, its verifier, a poll token, a
+// bearer, a forwarded runner key) is never printed, even when a server echoes
+// it back in an error. last-error.json hides the same values. Scrubbed again
+// after control characters are stripped, so one inside a secret can't hide it.
+function printErrorWithoutSecrets(message) {
+    const secrets = errorOutputSecrets();
+    printError(redactSecrets(sanitizeTerminalText(redactSecrets(message, { secrets })), { secrets }));
+}
 if (isCliEntrypoint()) {
     const rawArgs = process.argv.slice(2);
-    withPassiveUpdateNotice(rawArgs, getCliVersion, printError, args => 
+    withPassiveUpdateNotice(rawArgs, getCliVersion, printErrorWithoutSecrets, args => 
     // ORI-2429: the process-boundary adapter stays a Promise (ADR-038 guide); the record write is Effect-owned and never replaces this error.
     main(args).catch(async (error) => {
         const message = error instanceof Error ? error.message : 'Unknown error';

package/dist/instruction-delivery.d.ts

@@ -1,8 +1,8 @@
-import { type SyncDiskOptions, type SyncDiskResult, type SyncPayload, type SyncRequestPlan } from './instruction-set-sync/index.js';
+import { type Interrupted } from './cli-stops.js';
+import { stageSyncPayload, type SyncDiskOptions, type SyncDiskResult, type SyncPayload, type SyncRequestPlan } from './instruction-set-sync/index.js';
 import { type UpdatePlan, type UpdateResult } from './instruction-set-update/index.js';
-export interface Interrupted {
-    interrupted: 130 | 143;
-}
+/** Stages and publishes one version under the folder lock (tests and the fixture script). */
+export declare function syncPayloadToDisk(...args: Parameters<typeof stageSyncPayload>): Promise<SyncDiskResult>;
 export declare function syncInstructionSet(out: string, project: string, plan: SyncRequestPlan, options: SyncDiskOptions): Promise<Interrupted | {
     payload: SyncPayload;
     result: SyncDiskResult;

package/dist/instruction-delivery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instruction-delivery.d.ts","sourceRoot":"","sources":["../src/instruction-delivery.ts"],"names":[],"mappings":"AAIA,OAAO,EAA0D,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,KAAK,eAAe,EAAE,MAAM,iCAAiC,CAAA;AAC3L,OAAO,EAAsE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,MAAM,mCAAmC,CAAA;AAK1J,MAAM,WAAW,WAAW;IAAG,WAAW,EAAE,GAAG,GAAG,GAAG,CAAA;CAAE;AAkEvD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,eAAe;;;GAM/G;AAED,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,OAAO,EACnB,MAAM,EAAE,OAAO,GACd,OAAO,CAAC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,GAAG,WAAW,CAAC,CAiCnE"}
+{"version":3,"file":"instruction-delivery.d.ts","sourceRoot":"","sources":["../src/instruction-delivery.ts"],"names":[],"mappings":"AAIA,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAG/D,OAAO,EAAE,gBAAgB,EAAE,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,KAAK,eAAe,EAAE,MAAM,iCAAiC,CAAA;AACrJ,OAAO,EAA2F,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,MAAM,mCAAmC,CAAA;AA4B/K,6FAA6F;AAC7F,wBAAgB,iBAAiB,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC,CAEvG;AAeD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,eAAe;;;GAM/G;AAED,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,OAAO,EACnB,MAAM,EAAE,OAAO,GACd,OAAO,CAAC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,GAAG,WAAW,CAAC,CAuCnE"}

package/dist/instruction-delivery.js

@@ -1,11 +1,13 @@
+import { join } from 'node:path';
 import { Cause, Effect, Exit } from 'effect';
+import { runWithStops } from './cli-stops.js';
 import { authedFetch } from './http.js';
 import { responsePayload } from './json-response.js';
-import { stageSyncPayload, startSyncLockClaim, tryClaimSyncLock } from './instruction-set-sync/index.js';
-import { applyUpdate, lockedProfileIdentity, makeUpdatePlan, readUpdateLock } from './instruction-set-update/index.js';
-// Existing file steps throw plain errors; keep them as the failure value so the
-// CLI prints exactly the same message.
-const attempt = (operation) => Effect.try({ try: operation, catch: cause => cause });
+import { stageSyncPayload } from './instruction-set-sync/index.js';
+import { applyUpdate, lockedProfileIdentity, makeUpdatePlan, publishNoSyncUpdate, readUpdateLock } from './instruction-set-update/index.js';
+import { attempt, holdSyncLock } from './instruction-sync-lock.js';
+// Loaded only through `await import(...)` from instruction-sets-cli, so CLI
+// startup and the published loader never load Effect.
 function readPayload(path, action) {
     return Effect.tryPromise({
         // The body stays unchecked here, as before: stageSyncPayload and makeUpdatePlan validate it.
@@ -14,51 +16,29 @@ function readPayload(path, action) {
         catch: cause => cause,
     });
 }
-// Waiting for another process's lock is the only interruptible part: nothing
-// is held yet. Publishing runs to completion once the lock is ours.
-function holdSyncLock(appRoot, use) {
-    const acquire = Effect.gen(function* () {
-        const claim = yield* attempt(() => startSyncLockClaim(appRoot));
-        while (true) {
-            const claimed = yield* attempt(() => tryClaimSyncLock(claim));
-            if (typeof claimed === 'function')
-                return claimed;
-            yield* Effect.interruptible(Effect.sleep(claimed));
-        }
-    });
-    return Effect.acquireUseRelease(acquire, () => use, release => Effect.sync(release));
-}
-// Stage the version, publish it under the lock, and always remove an
-// unpublished stage, including after Ctrl-C or SIGTERM.
+// Stage the version, publish it under the lock (to completion once the lock
+// is ours), and always remove an unpublished stage, including after Ctrl-C or
+// SIGTERM.
 function deliverPayload(...args) {
     return Effect.acquireUseRelease(attempt(() => stageSyncPayload(...args)), staged => holdSyncLock(staged.appRoot, attempt(staged.publish)).pipe(Effect.map(warnings => ({ destination: staged.destination, wasPresent: staged.wasPresent, warnings }))), staged => Effect.sync(staged.discard));
 }
+/** Stages and publishes one version under the folder lock (tests and the fixture script). */
+export function syncPayloadToDisk(...args) {
+    return runOrThrow(deliverPayload(...args), new AbortController().signal);
+}
 async function runOrThrow(program, signal) {
     const exit = await Effect.runPromiseExit(program, { signal });
     if (Exit.isSuccess(exit))
         return exit.value;
     throw Cause.squash(exit.cause);
 }
-// `once`: a second signal falls through to Node's default kill.
 async function runDelivery(program) {
-    const controller = new AbortController();
-    let interrupted;
-    const handleInterrupt = () => { interrupted ??= 130; controller.abort(); };
-    const handleTerminate = () => { interrupted ??= 143; controller.abort(); };
-    process.once('SIGINT', handleInterrupt);
-    process.once('SIGTERM', handleTerminate);
-    try {
-        return await runOrThrow(program(controller.signal), controller.signal);
-    }
-    catch (error) {
-        if (interrupted !== undefined)
-            return { interrupted };
-        throw error;
-    }
-    finally {
-        process.removeListener('SIGINT', handleInterrupt);
-        process.removeListener('SIGTERM', handleTerminate);
-    }
+    const { exit, interrupted } = await runWithStops(program);
+    if (Exit.isSuccess(exit))
+        return exit.value;
+    if (interrupted !== undefined)
+        return { interrupted };
+    throw Cause.squash(exit.cause);
 }
 export function syncInstructionSet(out, project, plan, options) {
     return runDelivery(() => Effect.gen(function* () {
@@ -84,12 +64,18 @@ export function updateInstructionSets(out, project, isApproved, noSync) {
         const plan = yield* attempt(() => makeUpdatePlan(project, lock, payloads));
         if (!isApproved)
             return { plan, result: { absent: [], warnings: [] } };
-        // applyUpdate's own steps are not interruptible; each version it syncs is
-        // a nested delivery that the shared signal interrupts and cleans up.
-        const result = yield* Effect.uninterruptible(Effect.tryPromise({
-            try: () => applyUpdate(out, project, plan, noSync, undefined, (...args) => runOrThrow(deliverPayload(...args), signal)),
-            catch: cause => cause,
-        }));
+        // --no-sync writes the Lock under the folder lock. Otherwise applyUpdate's
+        // own steps are not interruptible; each version it syncs is a nested
+        // delivery that the shared signal interrupts and cleans up.
+        const result = noSync
+            ? yield* holdSyncLock(join(out, 'orizu'), Effect.uninterruptible(Effect.tryPromise({
+                try: () => publishNoSyncUpdate(out, project, plan),
+                catch: cause => cause,
+            })))
+            : yield* Effect.uninterruptible(Effect.tryPromise({
+                try: () => applyUpdate(out, project, plan, () => new Date(), (...args) => runOrThrow(deliverPayload(...args), signal)),
+                catch: cause => cause,
+            }));
         return { plan, result };
     });
     // --no-sync stages nothing to clean up, so keep Node's default signal

package/dist/instruction-prune.d.ts

@@ -0,0 +1,24 @@
+import { type Interrupted } from './cli-stops.js';
+import { type PrunePlan, type PruneResult } from './instruction-set-update/index.js';
+/** What the removal step did before a stop was handled. */
+export type PruneOutcome = {
+    kind: 'not started';
+} | {
+    kind: 'removed';
+    count: number;
+} | {
+    kind: 'rolled back';
+    error: unknown;
+} | {
+    kind: 'rollback failed';
+};
+export type PruneStopped = Interrupted & {
+    outcome: PruneOutcome;
+};
+/**
+ * Removes the approved Versions under the folder lock. Waiting for the lock
+ * and planning again can be stopped and change nothing. The removal itself
+ * always settles once it starts: applied and verified, or fully rolled back.
+ */
+export declare function pruneInstructionSets(out: string, plan: PrunePlan, keepSpecifiers: string[]): Promise<PruneResult | PruneStopped>;
+//# sourceMappingURL=instruction-prune.d.ts.map