presubmit 0.1.0

package/dist/packages/protocol/src/agents.js

@@ -0,0 +1,301 @@
+/** Project-local, declarative agents. No executable plugins or authority in instructions. */
+export const agentCapabilities = [
+    'workspace.read',
+    'snapshot.read',
+    'findings.report',
+    'user.ask',
+];
+function object(value, keys) {
+    if (!value ||
+        typeof value !== 'object' ||
+        Array.isArray(value) ||
+        Object.keys(value).some((k) => !keys.includes(k)))
+        throw new Error('Invalid agent contract fields.');
+    return value;
+}
+export function agentText(value, label, max = 120) {
+    if (typeof value !== 'string' || !value.trim() || value.length > max)
+        throw new Error(`Invalid ${label}.`);
+    return value;
+}
+export function agentId(value) {
+    const id = agentText(value, 'agent identifier');
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(id))
+        throw new Error('Invalid agent identifier.');
+    return id;
+}
+function version(value) {
+    if (!Number.isSafeInteger(value) || value < 1)
+        throw new Error('Invalid agent version.');
+    return value;
+}
+export function parseAgentCapabilities(value) {
+    if (!Array.isArray(value) ||
+        value.length > agentCapabilities.length ||
+        new Set(value).size !== value.length ||
+        value.some((c) => !agentCapabilities.includes(c)))
+        throw new Error('Unsupported or duplicate agent capability. V1 supports bounded reads, findings and user questions only.');
+    return [...value];
+}
+export function parseAgentDefinition(value) {
+    const v = object(value, [
+        'schemaVersion',
+        'projectId',
+        'id',
+        'version',
+        'name',
+        'instructions',
+        'requestedCapabilities',
+        'contextRequirements',
+        'output',
+    ]);
+    if (v.schemaVersion !== 1)
+        throw new Error('Unsupported agent schema version.');
+    const requestedCapabilities = parseAgentCapabilities(v.requestedCapabilities);
+    if (!Array.isArray(v.contextRequirements) ||
+        v.contextRequirements.length > 3 ||
+        new Set(v.contextRequirements).size !== v.contextRequirements.length ||
+        v.contextRequirements.some((c) => !['prompt', 'workspace', 'snapshot'].includes(c)))
+        throw new Error('Invalid context requirements.');
+    if (v.output !== 'conversation' && v.output !== 'review-findings')
+        throw new Error('Unsupported output contract.');
+    const contextRequirements = [...v.contextRequirements];
+    if (requestedCapabilities.includes('workspace.read') &&
+        !contextRequirements.includes('workspace'))
+        throw new Error('Workspace reads require workspace context.');
+    if ((requestedCapabilities.includes('snapshot.read') ||
+        requestedCapabilities.includes('findings.report')) &&
+        !contextRequirements.includes('snapshot'))
+        throw new Error('Snapshot tools require snapshot context.');
+    if (v.output === 'review-findings' && !requestedCapabilities.includes('findings.report'))
+        throw new Error('Findings output requires findings.report.');
+    if (v.output === 'conversation' && requestedCapabilities.includes('findings.report'))
+        throw new Error('Conversation output cannot publish findings.');
+    return {
+        schemaVersion: 1,
+        projectId: agentId(v.projectId),
+        id: agentId(v.id),
+        version: version(v.version),
+        name: agentText(v.name, 'name'),
+        instructions: agentText(v.instructions, 'instructions', 16000),
+        requestedCapabilities,
+        contextRequirements,
+        output: v.output,
+    };
+}
+export function parseAgentConnection(value) {
+    const v = object(value, [
+        'schemaVersion',
+        'projectId',
+        'id',
+        'version',
+        'agent',
+        'placement',
+        'trigger',
+        'inputMapping',
+        'permissionCeiling',
+        'resultDestination',
+    ]);
+    const agent = object(v.agent, ['id', 'version']);
+    const mapping = object(v.inputMapping, ['prompt', 'workspace', 'snapshot']);
+    const sources = {
+        prompt: 'user-message',
+        workspace: 'project-workspace',
+        snapshot: 'captured-snapshot',
+    };
+    for (const [key, source] of Object.entries(mapping))
+        if (source !== sources[key])
+            throw new Error('Unsupported input mapping.');
+    if (mapping.prompt !== 'user-message')
+        throw new Error('Manual connections require a prompt input mapping.');
+    if (v.schemaVersion !== 1 || v.trigger !== 'manual')
+        throw new Error('Only schema v1 manual connections are supported.');
+    if (v.placement !== 'conversation-action' && v.placement !== 'snapshot-action')
+        throw new Error('Unsupported placement.');
+    if (v.resultDestination !== 'conversation' && v.resultDestination !== 'review-findings')
+        throw new Error('Unsupported result destination.');
+    // A conversation action may run a snapshot reviewer, but its output still belongs
+    // to Reviews. Placement never changes the immutable-context security boundary.
+    if (v.resultDestination === 'review-findings' && !mapping.snapshot)
+        throw new Error('Findings destinations require immutable snapshot context.');
+    if (mapping.snapshot && mapping.workspace)
+        throw new Error('Snapshot context prohibits live workspace context.');
+    if (v.placement === 'snapshot-action' && (mapping.workspace || !mapping.snapshot))
+        throw new Error('Snapshot placement requires immutable snapshot context and prohibits live workspace context.');
+    const permissionCeiling = parseAgentCapabilities(v.permissionCeiling);
+    if (mapping.snapshot && permissionCeiling.includes('workspace.read'))
+        throw new Error('Snapshot context prohibits live workspace capabilities.');
+    return {
+        schemaVersion: 1,
+        projectId: agentId(v.projectId),
+        id: agentId(v.id),
+        version: version(v.version),
+        agent: { id: agentId(agent.id), version: version(agent.version) },
+        placement: v.placement,
+        trigger: 'manual',
+        inputMapping: { ...mapping },
+        permissionCeiling,
+        resultDestination: v.resultDestination,
+    };
+}
+/** Unknown host capabilities fail rather than silently claiming support. Restrictions only narrow. */
+export function resolveAgentCapabilities(definition, connection, host) {
+    const d = parseAgentDefinition(definition), c = parseAgentConnection(connection);
+    const supported = parseAgentCapabilities(host);
+    if (d.projectId !== c.projectId || d.id !== c.agent.id || d.version !== c.agent.version)
+        throw new Error('Connection belongs to another project or definition version.');
+    if (d.output !== c.resultDestination || d.contextRequirements.some((k) => !c.inputMapping[k]))
+        throw new Error('Incompatible connection context or result destination.');
+    const effective = d.requestedCapabilities.filter((cap) => supported.includes(cap) && c.permissionCeiling.includes(cap));
+    if (d.output === 'review-findings' && !effective.includes('findings.report'))
+        throw new Error('Connection or host denies required findings output capability.');
+    return effective;
+}
+export function parseAgentInput(value, connection) {
+    const v = object(value, ['prompt', 'snapshot']);
+    const prompt = agentText(v.prompt, 'invocation prompt', 20000);
+    if (JSON.stringify(value).length > 2_000_000)
+        throw new Error('Invocation input exceeds 2 MB character limit.');
+    if (!connection.inputMapping.prompt)
+        throw new Error('Connection does not map prompt input.');
+    if (!connection.inputMapping.snapshot) {
+        if (v.snapshot !== undefined)
+            throw new Error('Invocation snapshot does not match connection context.');
+        return { prompt };
+    }
+    if (!v.snapshot)
+        throw new Error('Invocation requires an immutable snapshot.');
+    const snapshot = object(v.snapshot, ['revision', 'files', 'baseFiles', 'diff', 'base', 'target']);
+    const files = (input) => {
+        if (!input ||
+            typeof input !== 'object' ||
+            Array.isArray(input) ||
+            Object.values(input).some((v) => typeof v !== 'string'))
+            throw new Error('Invalid snapshot files.');
+        return { ...input };
+    };
+    const parsed = {
+        revision: agentText(snapshot.revision, 'snapshot revision', 200),
+        files: files(snapshot.files),
+    };
+    if (snapshot.baseFiles !== undefined)
+        parsed.baseFiles = files(snapshot.baseFiles);
+    for (const key of ['base', 'target', 'diff']) {
+        if (snapshot[key] !== undefined) {
+            if (typeof snapshot[key] !== 'string')
+                throw new Error(`Invalid snapshot ${key}.`);
+            parsed[key] = snapshot[key];
+        }
+    }
+    return { prompt, snapshot: parsed };
+}
+/** Validate durable records too: corrupt/future state must not become launch authority. */
+export function parseAgentInvocation(value) {
+    const v = object(value, [
+        'schemaVersion',
+        'projectId',
+        'id',
+        'sessionId',
+        'runId',
+        'definition',
+        'connection',
+        'effectiveCapabilities',
+        'input',
+        'status',
+        'revision',
+        'createdAt',
+        'updatedAt',
+        'error',
+    ]);
+    if (v.schemaVersion !== 1)
+        throw new Error('Unsupported invocation schema version.');
+    const definition = parseAgentDefinition(v.definition), connection = parseAgentConnection(v.connection);
+    const projectId = agentId(v.projectId), id = agentId(v.id), sessionId = agentId(v.sessionId), runId = agentId(v.runId);
+    if (definition.projectId !== projectId || new Set([id, sessionId, runId]).size !== 3)
+        throw new Error('Invalid invocation project or isolated identity.');
+    const effectiveCapabilities = parseAgentCapabilities(v.effectiveCapabilities);
+    const allowed = resolveAgentCapabilities(definition, connection, effectiveCapabilities);
+    if (effectiveCapabilities.some((c) => !allowed.includes(c)))
+        throw new Error('Invocation capabilities exceed frozen authority.');
+    if (![
+        'prepared',
+        'running',
+        'cancelling',
+        'completed',
+        'failed',
+        'cancelled',
+        'interrupted',
+    ].includes(String(v.status)))
+        throw new Error('Invalid invocation status.');
+    const timestamp = (input) => {
+        const text = agentText(input, 'invocation timestamp', 40);
+        if (!Number.isFinite(Date.parse(text)) || new Date(text).toISOString() !== text)
+            throw new Error('Invalid invocation timestamp.');
+        return text;
+    };
+    return {
+        schemaVersion: 1,
+        projectId,
+        id,
+        sessionId,
+        runId,
+        definition,
+        connection,
+        effectiveCapabilities,
+        input: parseAgentInput(v.input, connection),
+        status: v.status,
+        revision: version(v.revision),
+        createdAt: timestamp(v.createdAt),
+        updatedAt: timestamp(v.updatedAt),
+        ...(v.error === undefined ? {} : { error: agentText(v.error, 'invocation error', 4000) }),
+    };
+}
+export function agentExamples(projectId) {
+    return [
+        {
+            id: 'snapshot-reviewer',
+            name: 'Snapshot reviewer',
+            instructions: 'Review the supplied immutable snapshot for actionable bugs. Report evidence-backed findings and finish with a concise summary.',
+            requestedCapabilities: ['snapshot.read', 'findings.report', 'user.ask'],
+            contextRequirements: ['prompt', 'snapshot'],
+            output: 'review-findings',
+            placement: 'snapshot-action',
+            inputMapping: { prompt: 'user-message', snapshot: 'captured-snapshot' },
+        },
+        {
+            id: 'project-summary',
+            name: 'Project summary',
+            instructions: 'Inspect the project and explain its purpose and structure in ordinary conversation. Cite relevant files and acknowledge uncertainty.',
+            requestedCapabilities: ['workspace.read', 'user.ask'],
+            contextRequirements: ['prompt', 'workspace'],
+            output: 'conversation',
+            placement: 'conversation-action',
+            inputMapping: { prompt: 'user-message', workspace: 'project-workspace' },
+        },
+    ].map((v) => {
+        const definition = parseAgentDefinition({
+            schemaVersion: 1,
+            projectId,
+            id: v.id,
+            version: 1,
+            name: v.name,
+            instructions: v.instructions,
+            requestedCapabilities: v.requestedCapabilities,
+            contextRequirements: v.contextRequirements,
+            output: v.output,
+        });
+        const connection = parseAgentConnection({
+            schemaVersion: 1,
+            projectId,
+            id: `${v.id}-manual`,
+            version: 1,
+            agent: { id: v.id, version: 1 },
+            placement: v.placement,
+            trigger: 'manual',
+            inputMapping: v.inputMapping,
+            permissionCeiling: v.requestedCapabilities,
+            resultDestination: v.output,
+        });
+        return { definition, connection };
+    });
+}

package/dist/packages/protocol/src/browser-access.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/protocol/src/checks.js

@@ -0,0 +1,40 @@
+/** Finite commands only. Results are passive observations, never task/review gates. */
+export const checkLimits = {
+    session: 2,
+    host: 4,
+    lifetimeMs: 60 * 60 * 1000,
+    tailBytes: 64 * 1024,
+    logBytes: 10 * 1024 * 1024,
+    hostBytes: 250 * 1024 * 1024,
+    retentionMs: 7 * 24 * 60 * 60 * 1000,
+};
+export const activeCheck = (check) => ['awaiting_approval', 'starting', 'running'].includes(check.state);
+export function parseCheckRequest(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Invalid check request');
+    const v = value;
+    const text = (key, max) => {
+        const t = v[key];
+        if (typeof t !== 'string' || !t.trim() || t.length > max || t.includes('\0'))
+            throw new Error(`Invalid check ${key}`);
+        return t;
+    };
+    if (v.action === 'start')
+        return {
+            action: 'start',
+            requestId: text('requestId', 128),
+            command: text('command', 20000),
+            purpose: text('purpose', 1000),
+            ...(v.taskId === undefined ? {} : { taskId: text('taskId', 128) }),
+        };
+    if (v.action === 'read') {
+        if (v.offset !== undefined && (!Number.isSafeInteger(v.offset) || Number(v.offset) < 0))
+            throw new Error('Invalid output offset');
+        return {
+            action: 'read',
+            checkId: text('checkId', 128),
+            offset: v.offset,
+        };
+    }
+    throw new Error('Unknown check action');
+}

package/dist/packages/protocol/src/child-sessions.js

@@ -0,0 +1,28 @@
+export const childSessionLimits = { depth: 2, totalSpawns: 8 };
+export function parseStartChildRequest(value) {
+    const v = value;
+    if (!v ||
+        typeof v !== 'object' ||
+        Array.isArray(v) ||
+        v.action !== 'start' ||
+        Object.keys(v).some((key) => !['action', 'requestKey', 'prompt', 'contextMode', 'attachments'].includes(key)) ||
+        typeof v.requestKey !== 'string' ||
+        !/^[a-zA-Z0-9_-]{1,128}$/.test(v.requestKey) ||
+        typeof v.prompt !== 'string' ||
+        !v.prompt.trim() ||
+        v.prompt.length > 200000 ||
+        (v.contextMode !== undefined && !['inherit', 'fresh'].includes(v.contextMode)) ||
+        (v.attachments !== undefined &&
+            (!Array.isArray(v.attachments) ||
+                v.attachments.length > 10 ||
+                v.attachments.some((id) => typeof id !== 'string' ||
+                    !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(id)))))
+        throw new Error('Supply a stable requestKey, self-contained prompt, inherit/fresh context, and at most 10 uploaded attachment IDs.');
+    return {
+        action: 'start',
+        requestKey: v.requestKey,
+        prompt: v.prompt,
+        contextMode: v.contextMode ?? 'inherit',
+        attachments: [...new Set(v.attachments ?? [])],
+    };
+}

package/dist/packages/protocol/src/command-policy.js

@@ -0,0 +1,3 @@
+/** Application-owned versions. Changing either invalidates outstanding dispatch grants. */
+export const commandPolicyRevision = 'command-policy-v1';
+export const commandGrammarVersion = 'literal-shell-v1';

package/dist/packages/protocol/src/coordinator.js

@@ -0,0 +1,135 @@
+import { parseStartChildRequest, } from './child-sessions.js';
+import { parseReviewRequest } from './reviewers.js';
+export function parseCoordinatorRequest(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Invalid coordinator request.');
+    const v = value;
+    if (v.action === 'start_review_session') {
+        if (Object.keys(v).some((key) => !['action', 'requestKey', 'scope', 'base', 'target', 'focus'].includes(key)) ||
+            typeof v.requestKey !== 'string' ||
+            !/^[a-zA-Z0-9_-]{1,128}$/.test(v.requestKey) ||
+            (v.focus !== undefined &&
+                !['general', 'correctness', 'security', 'tests'].includes(String(v.focus))))
+            throw new Error('Supply a stable requestKey and a valid reviewer focus.');
+        return {
+            action: 'start_review_session',
+            requestKey: v.requestKey,
+            ...parseReviewRequest(v),
+            ...(v.focus === undefined
+                ? {}
+                : { focus: v.focus }),
+        };
+    }
+    if (v.action === 'launch_tasks') {
+        if (Object.keys(v).some((key) => !['action', 'requestKey', 'revision', 'version', 'taskIds'].includes(key)) ||
+            typeof v.requestKey !== 'string' ||
+            !/^[a-zA-Z0-9_-]{1,128}$/.test(v.requestKey) ||
+            !Number.isSafeInteger(v.revision) ||
+            Number(v.revision) < 0 ||
+            !Number.isSafeInteger(v.version) ||
+            Number(v.version) < 0 ||
+            !Array.isArray(v.taskIds) ||
+            !v.taskIds.length ||
+            v.taskIds.length > 50 ||
+            new Set(v.taskIds).size !== v.taskIds.length ||
+            v.taskIds.some((id) => typeof id !== 'string' || !id.trim() || id.length > 80))
+            throw new Error('Supply a stable requestKey, current revision and version, and distinct stable task IDs from get_tasks.');
+        return {
+            action: 'launch_tasks',
+            requestKey: v.requestKey,
+            revision: v.revision,
+            version: v.version,
+            taskIds: [...v.taskIds],
+        };
+    }
+    if (v.action === 'start')
+        return parseStartChildRequest(v);
+    if (v.action === 'list' && Object.keys(v).length === 1)
+        return { action: 'list' };
+    if (v.action !== 'send' ||
+        Object.keys(v).some((key) => !['action', 'version', 'attemptId', 'message', 'attachments', 'requestKey', 'followUpToken'].includes(key)) ||
+        (v.requestKey !== undefined &&
+            (typeof v.requestKey !== 'string' || !/^[a-zA-Z0-9_-]{1,128}$/.test(v.requestKey))) ||
+        (v.followUpToken !== undefined &&
+            (typeof v.followUpToken !== 'string' || !/^[0-9a-f]{64}$/.test(v.followUpToken))) ||
+        !Number.isSafeInteger(v.version) ||
+        Number(v.version) < 0 ||
+        typeof v.attemptId !== 'string' ||
+        !v.attemptId.trim() ||
+        v.attemptId.length > 128 ||
+        typeof v.message !== 'string' ||
+        !v.message.trim() ||
+        v.message.length > 200000 ||
+        (v.attachments !== undefined &&
+            (!Array.isArray(v.attachments) ||
+                v.attachments.length > 10 ||
+                v.attachments.some((id) => typeof id !== 'string' ||
+                    !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(id)))))
+        throw new Error('Supply a child attempt, current version, message, and at most 10 attachment IDs.');
+    return {
+        action: 'send',
+        ...(v.requestKey === undefined ? {} : { requestKey: v.requestKey }),
+        ...(v.followUpToken === undefined ? {} : { followUpToken: v.followUpToken }),
+        version: v.version,
+        attemptId: v.attemptId,
+        message: v.message,
+        ...(v.attachments === undefined
+            ? {}
+            : { attachments: [...new Set(v.attachments)] }),
+    };
+}
+export function parseCoordinatorResult(value) {
+    const v = value;
+    if (!v ||
+        !Number.isSafeInteger(v.version) ||
+        v.version < 0 ||
+        (v.launch !== undefined &&
+            (!v.launch ||
+                v.launch.acceptance !== 'queued' ||
+                typeof v.launch.requestKey !== 'string' ||
+                !Array.isArray(v.launch.attempts) ||
+                !v.launch.attempts.length ||
+                v.launch.attempts.length > 50 ||
+                v.launch.attempts.some((a) => !a ||
+                    ![a.taskId, a.attemptId, a.sessionId].every((id) => typeof id === 'string' && !!id)))) ||
+        (v.startedSessionId !== undefined && typeof v.startedSessionId !== 'string') ||
+        (v.ordinaryChildren !== undefined &&
+            (!Array.isArray(v.ordinaryChildren) ||
+                v.ordinaryChildren.length > 100 ||
+                v.ordinaryChildren.some((child) => !child ||
+                    !['sessionId', 'parentSessionId', 'title', 'status', 'url'].every((key) => typeof child[key] === 'string')))) ||
+        !Array.isArray(v.children) ||
+        v.children.length > 100 ||
+        !Array.isArray(v.attachments) ||
+        v.attachments.length > 100 ||
+        (v.messageId !== undefined && typeof v.messageId !== 'string') ||
+        v.children.some((child) => !child ||
+            !['attemptId', 'sessionId', 'taskId', 'title'].every((key) => typeof child[key] === 'string') ||
+            ![
+                'queued',
+                'starting',
+                'running',
+                'waiting',
+                'needs_review',
+                'done',
+                'failed',
+                'interrupted',
+                'cancelled',
+            ].includes(child.status) ||
+            !Number.isSafeInteger(child.pendingReplies) ||
+            child.pendingReplies < 0 ||
+            typeof child.paused !== 'boolean' ||
+            (child.followUpToken !== undefined &&
+                (typeof child.followUpToken !== 'string' || !/^[0-9a-f]{64}$/.test(child.followUpToken))) ||
+            (child.question !== undefined && typeof child.question !== 'string') ||
+            (child.blockedReason !== undefined && typeof child.blockedReason !== 'string') ||
+            (child.summary !== undefined && typeof child.summary !== 'string')) ||
+        v.attachments.some((a) => !a ||
+            typeof a.id !== 'string' ||
+            typeof a.name !== 'string' ||
+            typeof a.type !== 'string' ||
+            !Number.isSafeInteger(a.size) ||
+            a.size < 0))
+        throw new Error('Invalid coordinator response.');
+    return v;
+}

package/dist/packages/protocol/src/delegation.js

@@ -0,0 +1,40 @@
+export function parseTaskResult(value) {
+    if (!value || typeof value !== 'object')
+        throw new Error('Invalid task result.');
+    const v = value;
+    for (const [key, max] of Object.entries({
+        summary: 8000,
+        changedAreas: 4000,
+        verification: 8000,
+        unresolved: 4000,
+    })) {
+        if (typeof v[key] !== 'string' ||
+            v[key].length > max ||
+            (['summary', 'verification'].includes(key) && !v[key].trim()))
+            throw new Error('Invalid task result. Include a summary and verification actually performed.');
+    }
+    return {
+        summary: v.summary,
+        changedAreas: v.changedAreas,
+        verification: v.verification,
+        unresolved: v.unresolved,
+    };
+}
+export function taskQueuedMessages(attempt) {
+    return (attempt.queuedReplies ?? []).map((reply) => ({
+        ...reply,
+        attachments: reply.attachments ?? [],
+        createdAt: reply.createdAt ?? attempt.createdAt,
+    }));
+}
+export const defaultDelegatedExecutionLimit = 5;
+export const minDelegatedExecutionLimit = 1;
+export const maxDelegatedExecutionLimit = 10;
+export const emptyDelegationState = () => ({
+    version: 0,
+    paused: true,
+    concurrency: defaultDelegatedExecutionLimit,
+    hostLimit: defaultDelegatedExecutionLimit,
+    batches: [],
+    attempts: [],
+});

package/dist/packages/protocol/src/git-diff.js

@@ -0,0 +1,71 @@
+/** Git quotes control characters and, by default, non-ASCII bytes in diff headers. */
+function quotedPath(path, octal) {
+    const escapes = {
+        7: '\\a',
+        8: '\\b',
+        9: '\\t',
+        10: '\\n',
+        11: '\\v',
+        12: '\\f',
+        13: '\\r',
+        34: '\\"',
+        92: '\\\\',
+    };
+    if (!octal)
+        return JSON.stringify(path);
+    return ('"' +
+        Array.from(new TextEncoder().encode(path), (byte) => escapes[byte] ??
+            (byte < 32 || byte >= 127
+                ? '\\' + byte.toString(8).padStart(3, '0')
+                : String.fromCharCode(byte))).join('') +
+        '"');
+}
+/** Workspace and review diffs use --no-renames, so both header paths identify the same file. */
+function headersForFile(path) {
+    const variants = (prefix) => [
+        prefix + path,
+        quotedPath(prefix + path, false),
+        quotedPath(prefix + path, true),
+    ];
+    return variants('a/').flatMap((left) => variants('b/').map((right) => `diff --git ${left} ${right}`));
+}
+/** Preserve unmatched sections too: file lists and live diffs can refresh independently. */
+export function diffSections(diff, paths) {
+    const names = new Map(paths.flatMap((path) => headersForFile(path).map((header) => [header, path])));
+    return diff
+        .split(/(?=^diff --git |^Untracked file excluded: )/m)
+        .filter(Boolean)
+        .map((value) => {
+        const header = value.split('\n', 1)[0];
+        let path = names.get(header) ?? header;
+        if (header.startsWith('Untracked file excluded: ')) {
+            try {
+                const excluded = JSON.parse(header.slice('Untracked file excluded: '.length));
+                if (typeof excluded === 'string')
+                    path = excluded;
+            }
+            catch {
+                // Preserve the original notice if its filename cannot be decoded.
+            }
+        }
+        let additions = 0;
+        let deletions = 0;
+        let inHunk = false;
+        for (const line of value.split('\n')) {
+            if (line.startsWith('@@ '))
+                inHunk = true;
+            else if (inHunk && line.startsWith('+'))
+                additions++;
+            else if (inHunk && line.startsWith('-'))
+                deletions++;
+        }
+        return { value, path, additions, deletions };
+    });
+}
+export function diffForFile(diff, path) {
+    const headers = new Set(headersForFile(path));
+    return diff
+        .split(/(?=^diff --git )/m)
+        .filter((section) => headers.has(section.split('\n', 1)[0]))
+        .join('');
+}

package/dist/packages/protocol/src/git-handoff.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/protocol/src/index.js

@@ -0,0 +1 @@
+export const reasoningLevels = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];