orizu 0.5.15 → 0.5.17

package/dist/archive-artifacts-cli.js

@@ -0,0 +1,215 @@
+/**
+ * ALI-1199 archive/restore commands and assignment inventory.
+ *
+ * Kept outside index.ts per the CLI line ratchet. The server owns
+ * authorization and idempotency; this module validates the CLI grammar and
+ * renders the canonical response without inventing client-side state.
+ */
+import { authedFetch } from './http.js';
+import { extractErrorMessage } from './error-response.js';
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const ARTIFACT_TYPES = {
+    app: 'app',
+    apps: 'app',
+    dataset: 'dataset',
+    datasets: 'dataset',
+    task: 'task',
+    tasks: 'task',
+    assignment: 'assignment',
+    assignments: 'assignment',
+    scorer: 'scorer',
+    scorers: 'scorer',
+    optimization: 'optimization',
+    optimizations: 'optimization',
+};
+function argValue(args, flag) {
+    const index = args.indexOf(flag);
+    if (index === -1 ||
+        index + 1 >= args.length ||
+        args[index + 1].startsWith('--')) {
+        return null;
+    }
+    return args[index + 1];
+}
+function sanitizeTerminalText(value) {
+    return String(value).replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g, '');
+}
+function columnWidths(headers, rows) {
+    return headers.map((header, index) => Math.max(header.length, ...rows.map(row => row[index]?.length || 0)));
+}
+function printTable(headers, rows, print) {
+    const widths = columnWidths(headers, rows);
+    print(headers.map((header, index) => header.padEnd(widths[index])).join('  '));
+    print(widths.map(width => '-'.repeat(width)).join('  '));
+    rows.forEach(row => {
+        print(row.map((cell, index) => cell.padEnd(widths[index])).join('  '));
+    });
+}
+export function printTaskSummaries(items, print) {
+    if (items.length === 0)
+        return print('No tasks found.');
+    printTable(['TASK ID', 'TASK NAME', 'STATUS', 'ARCHIVE', 'TEAM/PROJECT'], items.map(item => [
+        sanitizeTerminalText(item.id),
+        sanitizeTerminalText(item.title || '-'),
+        sanitizeTerminalText(item.status || '-'),
+        sanitizeTerminalText(item.archiveStatus || 'active'),
+        item.teamSlug && item.projectSlug
+            ? sanitizeTerminalText(`${item.teamSlug}/${item.projectSlug}`)
+            : 'unknown-project',
+    ]), print);
+}
+export function printAppSummaries(items, print) {
+    if (items.length === 0)
+        return print('No apps found.');
+    printTable(['APP ID', 'APP NAME', 'VERSION', 'ARCHIVE'], items.map(item => [
+        sanitizeTerminalText(item.id),
+        sanitizeTerminalText(item.name || '-'),
+        `v${item.currentVersionNum || 1}`,
+        sanitizeTerminalText(item.status || 'active'),
+    ]), print);
+}
+export function printDatasetSummaries(items, print) {
+    if (items.length === 0)
+        return print('No datasets found.');
+    printTable(['DATASET ID', 'DATASET', 'ROWS', 'ARCHIVE'], items.map(item => [
+        sanitizeTerminalText(item.id),
+        sanitizeTerminalText(item.name || '-'),
+        sanitizeTerminalText(item.rowCount),
+        sanitizeTerminalText(item.status || 'active'),
+    ]), print);
+}
+export function printScorerSummaries(items, print) {
+    if (items.length === 0)
+        return print('No scorers found.');
+    printTable(['ID', 'NAME', 'MODE', 'METRIC', 'ARCHIVE', 'IMPLEMENTATION'], items.map(item => [
+        sanitizeTerminalText(item.id),
+        sanitizeTerminalText(item.name),
+        sanitizeTerminalText(item.mode),
+        sanitizeTerminalText(item.metricLabel),
+        sanitizeTerminalText(item.status || 'active'),
+        sanitizeTerminalText(item.implementationKind),
+    ]), print);
+}
+async function parseJsonPayload(response, context) {
+    const contentType = response.headers.get('content-type') || '';
+    const rawBody = await response.text();
+    if (!contentType.includes('application/json')) {
+        throw new Error(`${context} returned non-JSON response (status ${response.status}). ` +
+            `Body preview: ${sanitizeTerminalText(rawBody.slice(0, 180))}`);
+    }
+    try {
+        return JSON.parse(rawBody);
+    }
+    catch {
+        throw new Error(`${context} returned invalid JSON (status ${response.status}). ` +
+            `Body preview: ${sanitizeTerminalText(rawBody.slice(0, 180))}`);
+    }
+}
+function parseStatus(args) {
+    const value = argValue(args, '--status') || 'active';
+    if (value !== 'active' && value !== 'archived' && value !== 'all') {
+        throw new Error('--status must be active, archived, or all');
+    }
+    return value;
+}
+function artifactUsage() {
+    return ('Usage: orizu <apps|datasets|tasks|assignments|scorers|optimizations> ' +
+        '<archive|restore> <id> [--project <team/project>] ' +
+        '[--assignee <user-id>] [--json]');
+}
+export async function archiveArtifactCommand(args, io) {
+    const artifactType = ARTIFACT_TYPES[args[0] || ''];
+    const action = args[1];
+    const artifactId = args[2];
+    if (!artifactType ||
+        (action !== 'archive' && action !== 'restore') ||
+        !artifactId ||
+        !UUID_PATTERN.test(artifactId)) {
+        throw new Error(artifactUsage());
+    }
+    const assigneeId = argValue(args, '--assignee');
+    if (assigneeId && !UUID_PATTERN.test(assigneeId)) {
+        throw new Error('--assignee must be a UUID');
+    }
+    if (artifactType !== 'assignment' && assigneeId) {
+        throw new Error('--assignee is only valid for assignment archive commands');
+    }
+    const projectArg = argValue(args, '--project');
+    const project = projectArg || await io.resolveProjectSlug(null);
+    const params = new URLSearchParams({ project });
+    const body = {
+        archived: action === 'archive',
+        ...(assigneeId ? { assigneeId } : {}),
+    };
+    const fetcher = io.fetcher || authedFetch;
+    const response = await fetcher(`/api/cli/archive-artifacts/${artifactType}/${encodeURIComponent(artifactId)}` +
+        `?${params.toString()}`, {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to ${action} ${artifactType}: ` +
+            await extractErrorMessage(response));
+    }
+    const data = await parseJsonPayload(response, `${action === 'archive' ? 'Archive' : 'Restore'} ${artifactType}`);
+    if (io.json) {
+        io.print(JSON.stringify(data));
+        return;
+    }
+    const verb = action === 'archive' ? 'Archived' : 'Restored';
+    const assigneeSuffix = data.artifact.assigneeId
+        ? ` for ${sanitizeTerminalText(data.artifact.assigneeId)}`
+        : '';
+    io.print(`${verb} ${sanitizeTerminalText(data.artifact.type)} ` +
+        `${sanitizeTerminalText(data.artifact.id)}${assigneeSuffix}.`);
+}
+export async function listAssignmentsCommand(args, io) {
+    const status = parseStatus(args);
+    const assigneeId = argValue(args, '--assignee');
+    if (assigneeId && !UUID_PATTERN.test(assigneeId)) {
+        throw new Error('--assignee must be a UUID');
+    }
+    const projectArg = argValue(args, '--project');
+    const project = projectArg || await io.resolveProjectSlug(null);
+    const params = new URLSearchParams({ project, status });
+    if (assigneeId)
+        params.set('assignee', assigneeId);
+    const fetcher = io.fetcher || authedFetch;
+    const response = await fetcher(`/api/cli/assignments?${params.toString()}`);
+    if (!response.ok) {
+        throw new Error(`Failed to list assignments: ${await extractErrorMessage(response)}`);
+    }
+    const data = await parseJsonPayload(response, 'Assignments list');
+    if (io.json) {
+        io.print(JSON.stringify(data));
+        return;
+    }
+    const rows = data.assignments || [];
+    if (rows.length === 0) {
+        io.print('No assignment task-groups found.');
+        return;
+    }
+    const printable = rows.map(row => ({
+        id: sanitizeTerminalText(row.taskId),
+        title: sanitizeTerminalText(row.taskTitle || '-'),
+        lifecycle: sanitizeTerminalText(row.taskStatus || '-'),
+        archive: sanitizeTerminalText(row.status || 'active'),
+        progress: `${row.completedAssignments}/${row.totalAssignments}`,
+    }));
+    const idWidth = Math.max('TASK ID'.length, ...printable.map(row => row.id.length));
+    const titleWidth = Math.max('TASK'.length, ...printable.map(row => row.title.length));
+    const lifecycleWidth = Math.max('LIFECYCLE'.length, ...printable.map(row => row.lifecycle.length));
+    const archiveWidth = Math.max('ARCHIVE'.length, ...printable.map(row => row.archive.length));
+    io.print(`${'TASK ID'.padEnd(idWidth)}  ${'TASK'.padEnd(titleWidth)}  ` +
+        `${'LIFECYCLE'.padEnd(lifecycleWidth)}  ` +
+        `${'ARCHIVE'.padEnd(archiveWidth)}  PROGRESS`);
+    io.print(`${'-'.repeat(idWidth)}  ${'-'.repeat(titleWidth)}  ` +
+        `${'-'.repeat(lifecycleWidth)}  ${'-'.repeat(archiveWidth)}  ` +
+        `${'-'.repeat('PROGRESS'.length)}`);
+    printable.forEach(row => {
+        io.print(`${row.id.padEnd(idWidth)}  ${row.title.padEnd(titleWidth)}  ` +
+            `${row.lifecycle.padEnd(lifecycleWidth)}  ` +
+            `${row.archive.padEnd(archiveWidth)}  ${row.progress}`);
+    });
+}

package/dist/artifact-archive.js

@@ -11,7 +11,9 @@ const ARTIFACT_EXCLUDED_PATH_NAMES = new Set([
 function isNodeError(error) {
     return error instanceof Error;
 }
-function expandHomePath(path) {
+/** Exported for runner-dir-verify (ALI-1159): the pre-exec scan must resolve
+ * the same directory this module hashes and the runner later executes. */
+export function expandHomePath(path) {
     if (path.startsWith('~/')) {
         const home = process.env.HOME || '';
         return `${home}/${path.slice(2)}`;
@@ -123,7 +125,13 @@ export function createStoredZip(entries) {
     endOfCentralDirectory.writeUInt16LE(0, 20);
     return Buffer.concat([...localParts, centralDirectory, endOfCentralDirectory]);
 }
-export function zipDirectoryToBase64(dirArg) {
+/**
+ * Read the exact entry set the deterministic archive covers (sorted relative
+ * paths + bytes). Exported for runner-dir-verify (ALI-1159): the verified
+ * snapshot must be materialized from the SAME in-memory bytes that were
+ * hashed, so a post-hash mutation of the directory cannot change what runs.
+ */
+export function readArtifactEntries(dirArg) {
     const sourceDir = expandHomePath(dirArg);
     try {
         const stats = statSync(sourceDir);
@@ -141,12 +149,20 @@ export function zipDirectoryToBase64(dirArg) {
     if (files.length === 0) {
         throw new Error(`Directory contains no artifact files: ${sourceDir}`);
     }
-    const bytes = createStoredZip(files.map(relativePath => ({
+    return files.map(relativePath => ({
         path: relativePath,
         data: readFileSync(join(sourceDir, relativePath)),
-    })));
+        mode: statSync(join(sourceDir, relativePath)).mode,
+    }));
+}
+/** Deterministic archive of an already-read entry set. */
+export function archiveArtifactEntries(entries) {
+    const bytes = createStoredZip(entries);
     return {
         zipBase64: bytes.toString('base64'),
         contentSha256: createHash('sha256').update(bytes).digest('hex'),
     };
 }
+export function zipDirectoryToBase64(dirArg) {
+    return archiveArtifactEntries(readArtifactEntries(dirArg));
+}

package/dist/dataset-edit-rows.js

@@ -0,0 +1,90 @@
+import { extractErrorMessage } from './error-response.js';
+import { parseDatasetFile } from './file-parser.js';
+import { authedFetch } from './http.js';
+const MAX_REQUEST_BYTES = 3 * 1024 * 1024;
+const MAX_CHUNK_ROWS = 10;
+const EMPTY_REQUEST_BYTES = Buffer.byteLength('{"rows":[]}', 'utf8');
+function normalizeRows(rows) {
+    if (rows.length === 0) {
+        throw new Error('Dataset edit file must contain at least one row');
+    }
+    const seenRowIds = new Set();
+    return rows.map((row, index) => {
+        const rowId = typeof row.id === 'string' ? row.id.trim() : '';
+        if (!rowId) {
+            throw new Error(`Dataset edit file rows[${index}] must include a non-empty string id`);
+        }
+        if (seenRowIds.has(rowId)) {
+            throw new Error(`Dataset edit file rows[${index}].id duplicates a previous row id`);
+        }
+        seenRowIds.add(rowId);
+        return { ...row, id: rowId };
+    });
+}
+function chunkRows(rows, sanitize) {
+    const chunks = [];
+    let currentChunk = [];
+    let currentBytes = EMPTY_REQUEST_BYTES;
+    for (const row of rows) {
+        const rowBytes = Buffer.byteLength(JSON.stringify(row), 'utf8');
+        const framedRowBytes = rowBytes + (currentChunk.length > 0 ? 1 : 0);
+        if (currentChunk.length > 0 &&
+            (currentChunk.length >= MAX_CHUNK_ROWS || currentBytes + framedRowBytes > MAX_REQUEST_BYTES)) {
+            chunks.push(currentChunk);
+            currentChunk = [];
+            currentBytes = EMPTY_REQUEST_BYTES;
+        }
+        const singleRowRequestBytes = EMPTY_REQUEST_BYTES + rowBytes;
+        if (singleRowRequestBytes > MAX_REQUEST_BYTES) {
+            throw new Error(`Dataset edit row ${sanitize(row.id)} is ${singleRowRequestBytes} bytes, ` +
+                `which exceeds the ${MAX_REQUEST_BYTES}-byte edit request limit`);
+        }
+        currentChunk.push(row);
+        currentBytes += rowBytes + (currentChunk.length > 1 ? 1 : 0);
+    }
+    if (currentChunk.length > 0)
+        chunks.push(currentChunk);
+    return chunks;
+}
+export async function editDatasetRows(options) {
+    const { rows } = parseDatasetFile(options.file);
+    const chunks = chunkRows(normalizeRows(rows), options.sanitize);
+    let totalUpdated = 0;
+    let lastResult = null;
+    for (let index = 0; index < chunks.length; index += 1) {
+        const chunk = chunks[index];
+        if (!options.json && chunks.length > 1) {
+            options.printLine(`Updating chunk ${index + 1}/${chunks.length} (${chunk.length} rows)...`);
+        }
+        try {
+            const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(options.datasetId)}/rows`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ rows: chunk }),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${await extractErrorMessage(response)}`);
+            }
+            const data = await response.json();
+            if (!Number.isInteger(data.updatedCount) || data.updatedCount !== chunk.length) {
+                throw new Error(`Server reported ${String(data.updatedCount)} updated rows for a ${chunk.length}-row chunk`);
+            }
+            totalUpdated += data.updatedCount;
+            lastResult = data;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Chunk ${index + 1}/${chunks.length} failed: ${message}\n` +
+                `${totalUpdated} rows from ${index} chunk(s) were already updated. ` +
+                'Retry with a file containing only the remaining row edits.');
+        }
+    }
+    if (!lastResult)
+        throw new Error('Dataset edit file must contain at least one row');
+    if (options.json) {
+        options.printJson({ dataset: lastResult.dataset, updatedCount: totalUpdated });
+        return;
+    }
+    options.printLine(`Updated ${totalUpdated} rows in dataset ${options.sanitize(lastResult.dataset.name)} ` +
+        `(${options.sanitize(lastResult.dataset.id)}). Current row count: ${lastResult.dataset.rowCount}`);
+}

package/dist/dataset-upload-snapshot.js

@@ -0,0 +1,22 @@
+export async function ensureDatasetUploadSnapshot(dataset, jsonOutput, createSnapshot) {
+    try {
+        return await createSnapshot(dataset.id);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        const retryCommand = `orizu datasets versions create --dataset ${dataset.id}`;
+        if (jsonOutput) {
+            throw new Error(JSON.stringify({
+                error: 'Dataset upload completed but dataset version creation failed',
+                detail,
+                upload_completed: true,
+                dataset_id: dataset.id,
+                dataset_version_id: null,
+                retry_command: retryCommand,
+            }));
+        }
+        throw new Error(`Dataset upload completed but dataset version creation failed: ${detail}\n` +
+            `Dataset ${dataset.name} (${dataset.id}) was created with ${dataset.rowCount} rows. ` +
+            `Retry only the snapshot step with: ${retryCommand}`);
+    }
+}

package/dist/diff-comments-cli.js

@@ -0,0 +1,139 @@
+const DETAIL_LEVELS = ['hunk', 'diff', 'full'];
+function isCandidatePair(pair) {
+    return 'candidateId' in pair.from;
+}
+function usage() {
+    return 'Usage: orizu comments diff (--run <run-id> | --prompt <prompt-id>) [--from <revision> --to <revision>] [--detail hunk|diff|full] [--json]';
+}
+function sanitizeHumanText(ctx, value) {
+    return ctx.sanitizeTerminalText(value).replaceAll('\r', '');
+}
+function sanitizeHumanInlineText(ctx, value) {
+    return sanitizeHumanText(ctx, value).replaceAll('\n', '\\n');
+}
+function humanLineNumber(ctx, line) {
+    return line === null ? '-' : sanitizeHumanText(ctx, String(line + 1));
+}
+function buildParams(ctx) {
+    const runId = ctx.getArg('--run');
+    const promptId = ctx.getArg('--prompt');
+    const from = ctx.getArg('--from');
+    const to = ctx.getArg('--to');
+    const detail = ctx.getArg('--detail') ?? 'diff';
+    for (const [name, value] of [
+        ['--run', runId],
+        ['--prompt', promptId],
+        ['--from', from],
+        ['--to', to],
+        ['--detail', detail],
+    ]) {
+        ctx.rejectDashPrefixedOptionValue(name, value);
+    }
+    if (Number(Boolean(runId)) + Number(Boolean(promptId)) !== 1) {
+        throw new Error(usage());
+    }
+    if (Boolean(from) !== Boolean(to)) {
+        throw new Error('--from and --to must be provided together');
+    }
+    if (!DETAIL_LEVELS.includes(detail)) {
+        throw new Error('--detail must be hunk, diff, or full');
+    }
+    if (promptId && from && to) {
+        if (!Number.isInteger(Number(from)) || !Number.isInteger(Number(to))) {
+            throw new Error('--from and --to must be integer prompt versions');
+        }
+    }
+    const params = new URLSearchParams();
+    params.set(runId ? 'run' : 'prompt', (runId ?? promptId));
+    if (from && to) {
+        params.set('from', from);
+        params.set('to', to);
+    }
+    params.set('detail', detail);
+    return params;
+}
+function printDiffComments(ctx, payload) {
+    ctx.printLine(`Diff comments: ${payload.pairs.length} pair${payload.pairs.length === 1 ? '' : 's'}`);
+    if (payload.pairs.length === 0) {
+        ctx.printLine('');
+        ctx.printLine('No diff comments found.');
+        return;
+    }
+    for (const pair of payload.pairs) {
+        const hasCandidateIds = isCandidatePair(pair);
+        const from = hasCandidateIds ? pair.from.candidateId : String(pair.from.version);
+        const to = hasCandidateIds ? pair.to.candidateId : String(pair.to.version);
+        ctx.printLine('');
+        ctx.printLine(`${hasCandidateIds ? 'Candidates' : 'Versions'} ` +
+            `${sanitizeHumanInlineText(ctx, from)} → ${sanitizeHumanInlineText(ctx, to)}`);
+        if (pair.degraded) {
+            ctx.printLine(`  Context unavailable: ${sanitizeHumanText(ctx, pair.degraded.reason)}`);
+        }
+        if (pair.diff !== null) {
+            ctx.printLine('  Diff:');
+            for (const line of sanitizeHumanText(ctx, pair.diff).split('\n')) {
+                ctx.printLine(`    ${line}`);
+            }
+        }
+        if (pair.bodies !== null) {
+            for (const [label, body] of [
+                ['From body', pair.bodies.from],
+                ['To body', pair.bodies.to],
+            ]) {
+                ctx.printLine(`  ${label}:`);
+                for (const line of sanitizeHumanText(ctx, body).split('\n')) {
+                    ctx.printLine(`    ${line}`);
+                }
+            }
+        }
+        for (const comment of pair.comments) {
+            const authorName = comment.author?.person?.name || comment.author?.name || 'Unknown';
+            ctx.printLine(`  ${sanitizeHumanInlineText(ctx, comment.id)} · ` +
+                `${sanitizeHumanInlineText(ctx, authorName)} · ` +
+                `${sanitizeHumanInlineText(ctx, comment.createdAt)} · ` +
+                `${sanitizeHumanInlineText(ctx, comment.anchor.side)} line ` +
+                `${sanitizeHumanInlineText(ctx, String(comment.anchor.line + 1))}`);
+            for (const line of sanitizeHumanText(ctx, comment.body).split('\n')) {
+                ctx.printLine(`    ${line}`);
+            }
+            if (!comment.context) {
+                ctx.printLine(`    Context unavailable: ` +
+                    `${sanitizeHumanText(ctx, comment.contextUnavailableReason ?? 'body_unresolvable')}`);
+                continue;
+            }
+            for (const line of comment.context.hunk.lines) {
+                const prefix = line.op === 'add' ? '+' : line.op === 'del' ? '-' : ' ';
+                const isAnchored = comment.anchor.side === 'old'
+                    ? line.oldLine === comment.anchor.line
+                    : line.newLine === comment.anchor.line;
+                const marker = isAnchored ? '>' : ' ';
+                ctx.printLine(`    ${marker} old:${humanLineNumber(ctx, line.oldLine)} ` +
+                    `new:${humanLineNumber(ctx, line.newLine)} | ` +
+                    `${prefix}${sanitizeHumanText(ctx, line.text)}`);
+            }
+        }
+    }
+}
+export async function diffCommentsCommand(ctx) {
+    const params = buildParams(ctx);
+    const response = await ctx.authedFetch(`/api/cli/diff-comments?${params.toString()}`);
+    if (!response.ok) {
+        let message = `HTTP ${response.status}`;
+        try {
+            const payload = await response.clone().json();
+            if (typeof payload.error === 'string' && payload.error.trim()) {
+                message = sanitizeHumanInlineText(ctx, payload.error);
+            }
+        }
+        catch {
+            // Keep the status-only error for non-JSON responses.
+        }
+        throw new Error(`Failed to fetch diff comments: ${message}`);
+    }
+    const payload = await ctx.parseJsonResponse(response, 'Diff comments');
+    if (ctx.hasJsonFlag()) {
+        ctx.printJson(payload);
+        return;
+    }
+    printDiffComments(ctx, payload);
+}

package/dist/egress-allowlist-cli.js

@@ -13,6 +13,12 @@
  * with an injected fetcher.
  */
 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;
 }
@@ -55,22 +61,72 @@ function splitDomains(value) {
         .map(d => d.trim())
         .filter(d => d.length > 0);
 }
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((d) => typeof d === 'string') : [];
+}
+/**
+ * Re-derive the "beyond the 100-domain cap" entries from a stored set the
+ * SAME way the GET route does (positional over UNIQUE VALID domains): the
+ * coordinator applies only the first MAX_ADDITIVE_EGRESS_DOMAINS valid
+ * domains, so every valid entry past that index is configured-but-inert.
+ * Stored entries are already canonical + deduped by the write RPC, and the
+ * invalid (grandfathered) ones — flagged by the server — are not "valid"
+ * and so never consume a cap slot. Used for the PUT response, where a
+ * 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) {
+    const invalidSet = new Set(invalid);
+    const capped = [];
+    let validCount = 0;
+    for (const d of stored) {
+        if (invalidSet.has(d))
+            continue;
+        validCount += 1;
+        if (validCount > MAX_ADDITIVE_EGRESS_DOMAINS)
+            capped.push(d);
+    }
+    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 Array.isArray(data.extraDomains) ? data.extraDomains.filter((d) => typeof d === 'string') : [];
+    return {
+        domains: stringArray(data.extraDomains),
+        invalid: stringArray(data.invalidDomains),
+        capped: stringArray(data.cappedDomains),
+    };
 }
-function emit(io, teamSlug, domains) {
+function emit(io, teamSlug, current) {
     if (io.json) {
-        io.print(JSON.stringify({ teamSlug, extraDomains: domains }));
+        io.print(JSON.stringify({
+            teamSlug,
+            extraDomains: current.domains,
+            invalidDomains: current.invalid,
+            cappedDomains: current.capped,
+        }));
         return;
     }
-    io.print(domains.length === 0
+    const invalid = new Set(current.invalid);
+    const capped = new Set(current.capped);
+    const lines = current.domains.map((d) => {
+        // Round 4 (P3): re-adding a non-grandfathered invalid entry is
+        // guaranteed to fail the write RPC's tightened validator (grandfathering
+        // is retention-only — see set_team_egress_allowlist), so "remove and
+        // re-add" was actively misleading. The only viable remediation is
+        // removal.
+        if (invalid.has(d))
+            return `${d} (invalid — will not take effect; remove it (this value is no longer valid and cannot be re-added))`;
+        if (capped.has(d))
+            return `${d} (beyond the 100-domain cap — will not take effect)`;
+        return d;
+    });
+    io.print(lines.length === 0
         ? `${teamSlug}: no additive egress domains (base allowlist only)`
-        : `${teamSlug} additive egress domains:\n  ${domains.join('\n  ')}`);
+        : `${teamSlug} additive egress domains:\n  ${lines.join('\n  ')}`);
 }
 export async function egressAllowlistCommand(args, io) {
     const teamSlug = firstPositional(args);
@@ -100,7 +156,7 @@ export async function egressAllowlistCommand(args, io) {
         }
         else {
             const current = await fetchCurrent(fetcher, path);
-            const set = new Set(current);
+            const set = new Set(current.domains);
             if (addValue)
                 for (const d of splitDomains(addValue))
                     set.add(d);
@@ -119,10 +175,16 @@ export async function egressAllowlistCommand(args, io) {
             return 1;
         }
         const data = (await response.json());
-        const stored = Array.isArray(data.extraDomains)
-            ? data.extraDomains.filter((d) => typeof d === 'string')
-            : next;
-        emit(io, teamSlug, stored);
+        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) {

package/dist/egress-policy.js

@@ -117,6 +117,17 @@ export function baseEgressDomains(opts = {}) {
     }
     for (const d of GIT_HOST_DOMAINS)
         domains.add(d);
+    for (const d of opts.repositoryHosts ?? []) {
+        const normalized = normalizeEgressDomain(d);
+        // Repository hosts come from a validated remote and must remain exact:
+        // no URL normalization, leading wildcard, path, port, or case drift is
+        // accepted at this final firewall seam.
+        if (normalized &&
+            !normalized.startsWith('*.') &&
+            normalized === d.trim().toLowerCase()) {
+            domains.add(normalized);
+        }
+    }
     return [...domains];
 }
 /**
@@ -136,6 +147,7 @@ export function buildEgressPolicy(opts = {}) {
         orizuBaseUrl: opts.orizuBaseUrl,
         modelHost: brokerHost,
         modelHosts: opts.modelHosts,
+        repositoryHosts: opts.repositoryHosts,
     });
     const allow = {};
     for (const domain of base)