presubmit 0.1.0

package/dist/apps/server/src/task-capacity.js

@@ -0,0 +1,92 @@
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { defaultDelegatedExecutionLimit, maxDelegatedExecutionLimit, minDelegatedExecutionLimit, } from '../../../packages/protocol/src/delegation.js';
+function readSettings(path) {
+    const defaults = { version: '0', limit: defaultDelegatedExecutionLimit, parallelFileReads: true };
+    if (!path)
+        return defaults;
+    try {
+        const value = JSON.parse(readFileSync(path, 'utf8'));
+        if (typeof value.version !== 'string' ||
+            !Number.isInteger(value.limit) ||
+            value.limit < minDelegatedExecutionLimit ||
+            value.limit > maxDelegatedExecutionLimit ||
+            (value.parallelFileReads !== undefined && typeof value.parallelFileReads !== 'boolean'))
+            throw new Error('Invalid delegated execution settings.');
+        return { ...defaults, ...value };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return defaults;
+        throw error;
+    }
+}
+/** Shared by all projects in one host. Each parent session has its own delegated execution allowance. */
+export class TaskCapacity {
+    settingsPath;
+    leases = new Map();
+    settings;
+    constructor(settingsPath) {
+        this.settingsPath = settingsPath;
+        this.settings = readSettings(settingsPath);
+    }
+    get limit() {
+        return this.settings.limit;
+    }
+    state() {
+        return { ...this.settings };
+    }
+    save(input) {
+        const value = input;
+        if (!value ||
+            typeof value !== 'object' ||
+            typeof value.version !== 'string' ||
+            value.version !== this.settings.version)
+            throw new Error('Execution settings changed. Reload before saving.');
+        const limit = value.limit;
+        if (!Number.isInteger(limit) ||
+            limit < minDelegatedExecutionLimit ||
+            limit > maxDelegatedExecutionLimit)
+            throw new Error(`Maximum child sessions must be between ${minDelegatedExecutionLimit} and ${maxDelegatedExecutionLimit}.`);
+        if (value.parallelFileReads !== undefined && typeof value.parallelFileReads !== 'boolean')
+            throw new Error('Invalid parallel file reads setting.');
+        const next = {
+            version: randomUUID(),
+            limit: limit,
+            parallelFileReads: value.parallelFileReads ?? this.settings.parallelFileReads,
+        };
+        if (this.settingsPath) {
+            mkdirSync(dirname(this.settingsPath), { recursive: true, mode: 0o700 });
+            const temporary = `${this.settingsPath}.${randomUUID()}`;
+            try {
+                writeFileSync(temporary, JSON.stringify(next), { mode: 0o600 });
+                renameSync(temporary, this.settingsPath);
+            }
+            finally {
+                rmSync(temporary, { force: true });
+            }
+        }
+        this.settings = next;
+        return this.state();
+    }
+    acquire(owner, coordinator, userRequested = false) {
+        if (this.leases.has(owner))
+            return true;
+        if (!userRequested && this.blockedReason(owner, coordinator))
+            return false;
+        this.leases.set(owner, coordinator);
+        return true;
+    }
+    blockedReason(owner, coordinator) {
+        if (this.leases.has(owner))
+            return undefined;
+        const active = [...this.leases.values()].filter((value) => value === coordinator).length;
+        if (active >= this.limit)
+            return `Waiting for execution capacity: ${active}/${this.limit} session slots in use.`;
+        return undefined;
+    }
+    release(owner) {
+        this.leases.delete(owner);
+    }
+}

package/dist/apps/server/src/task-graph.js

@@ -0,0 +1,190 @@
+import { activeCheck } from '../../../packages/protocol/src/checks.js';
+import { taskDisplayId } from '../../../packages/protocol/src/planning.js';
+const sessionKey = (id) => `session:${id}`;
+const taskKey = (sessionId, id) => `task:${sessionId}:${id}`;
+const done = (attempt) => !!attempt && ['done', 'needs_review'].includes(attempt.status);
+export function projectTaskGraph(sessions, stateFor) {
+    const nodes = [];
+    const edges = [];
+    const aliases = new Map();
+    const directory = new Map(sessions.map((session) => [session.id, session]));
+    for (const session of sessions.filter((item) => !item.archived && !item.assignment)) {
+        const state = stateFor(session.id);
+        const board = state?.planning;
+        const delegation = state?.delegation;
+        const latest = new Map(delegation?.attempts.map((attempt) => [attempt.taskId, attempt]));
+        const tasks = new Map(board?.tasks.map((task) => [task.id, task]));
+        for (const attempt of latest.values())
+            if (!tasks.has(attempt.taskId))
+                tasks.set(attempt.taskId, attempt.task);
+        const references = [...tasks.values()];
+        for (const task of tasks.values()) {
+            const attempt = latest.get(task.id);
+            const child = attempt && directory.get(attempt.sessionId);
+            const node = {
+                id: taskKey(session.id, task.id),
+                kind: 'task',
+                title: task.title,
+                tag: taskDisplayId(task.id, references),
+                coordinatorId: session.id,
+                taskId: task.id,
+                sessionId: child?.id,
+                branch: child?.branch,
+                description: task.scope,
+                criteria: task.criteria,
+                status: 'idle',
+                statusLabel: 'Draft',
+            };
+            const unmet = (task.dependencies ?? []).filter((id) => !done(latest.get(id)));
+            const question = board?.questions.find((q) => q.blocking && !q.answer.trim() && (!q.taskIds?.length || q.taskIds.includes(task.id)));
+            if (attempt) {
+                const active = ['starting', 'running', 'waiting'].includes(attempt.status);
+                if (child?.status === 'unavailable') {
+                    node.status = 'failed';
+                    node.statusLabel = 'Unavailable';
+                    node.reason = child.error;
+                    node.unavailable = true;
+                }
+                else if (active && (attempt.pendingApprovals || child?.pendingApprovals)) {
+                    node.status = 'attention';
+                    node.statusLabel = 'Needs permission';
+                    node.reason = 'Open the conversation to review the pending command.';
+                }
+                else if (active && (attempt.question || child?.pendingQuestions)) {
+                    node.status = 'attention';
+                    node.statusLabel = 'Question';
+                    node.reason = attempt.question || 'The agent needs your answer to continue.';
+                }
+                else if (done(attempt)) {
+                    node.status = 'done';
+                    node.statusLabel = 'Done';
+                    node.reason = attempt.result?.summary;
+                }
+                else if (attempt.status === 'failed' || attempt.status === 'interrupted') {
+                    node.status = attempt.status === 'failed' ? 'failed' : 'attention';
+                    node.statusLabel = attempt.status === 'failed' ? 'Failed' : 'Interrupted';
+                    node.reason = attempt.error || 'Open task controls to review and retry this attempt.';
+                }
+                else if (attempt.status === 'queued') {
+                    const paused = delegation?.paused && !attempt.resumeRequested;
+                    node.status = unmet.length || attempt.blockedReason ? 'blocked' : 'idle';
+                    node.statusLabel = paused ? 'Paused' : node.status === 'blocked' ? 'Blocked' : 'Queued';
+                    node.reason = attempt.blockedReason || (paused ? 'Task execution is paused.' : undefined);
+                }
+                else if (attempt.status === 'cancelled') {
+                    node.statusLabel = 'Cancelled';
+                }
+                else {
+                    node.status = attempt.status === 'waiting' ? 'attention' : 'running';
+                    node.statusLabel = attempt.status === 'waiting' ? 'Waiting' : 'Running';
+                }
+            }
+            else if (question || task.status === 'needs_clarification') {
+                node.status = 'attention';
+                node.statusLabel = 'Needs clarification';
+                node.reason = question?.text || 'Clarify the scope with the coordinator.';
+            }
+            else if (task.status === 'ready' && task.criteria.trim()) {
+                node.status = unmet.length ? 'blocked' : 'ready';
+                node.statusLabel = unmet.length ? 'Blocked' : 'Ready';
+            }
+            else if (task.status === 'deferred')
+                node.statusLabel = 'Deferred';
+            if (node.status === 'blocked' && !node.reason)
+                node.reason = `Waiting for ${unmet.map((id) => taskDisplayId(id, references) ?? id).join(', ')} to finish.`;
+            nodes.push(node);
+            edges.push({ from: sessionKey(session.id), to: node.id, kind: 'child' });
+            for (const id of task.dependencies ?? [])
+                if (tasks.has(id))
+                    edges.push({ from: taskKey(session.id, id), to: node.id, kind: 'dependency' });
+        }
+        for (const attempt of delegation?.attempts ?? [])
+            aliases.set(attempt.sessionId, taskKey(session.id, attempt.taskId));
+    }
+    for (const session of sessions) {
+        if ((session.archived && !session.activeChecks) || aliases.has(session.id))
+            continue;
+        // An unused main workspace adds no context to a project's graph.
+        if (session.id === 'main' &&
+            !session.runs &&
+            !stateFor(session.id)?.checks?.length &&
+            !edges.some((edge) => edge.from === sessionKey('main')) &&
+            !sessions.some((child) => !child.archived && child.parentSessionId === 'main'))
+            continue;
+        const node = {
+            id: sessionKey(session.id),
+            kind: 'session',
+            title: session.id === 'main' ? 'Main workspace' : session.title,
+            sessionId: session.id,
+            branch: session.branch,
+            description: session.latestActivity?.slice(0, 600),
+            status: 'idle',
+            statusLabel: 'Idle',
+            unavailable: session.status === 'unavailable',
+        };
+        if (session.pendingApprovals || session.pendingQuestions || session.status === 'waiting') {
+            node.status = 'attention';
+            node.statusLabel = session.pendingApprovals
+                ? 'Needs permission'
+                : session.pendingQuestions
+                    ? 'Question'
+                    : 'Waiting';
+        }
+        else if (session.status === 'running') {
+            node.status = 'running';
+            node.statusLabel = 'Running';
+        }
+        else if (session.status === 'completed') {
+            node.status = 'done';
+            node.statusLabel = 'Done';
+        }
+        else if (session.status === 'failed' || session.status === 'unavailable') {
+            node.status = 'failed';
+            node.statusLabel = session.status === 'failed' ? 'Failed' : 'Unavailable';
+            node.reason = session.error;
+        }
+        else if (session.status === 'interrupted') {
+            node.status = 'attention';
+            node.statusLabel = 'Interrupted';
+        }
+        nodes.push(node);
+        const parent = session.parentSessionId ?? session.assignment?.coordinatorId;
+        if (parent)
+            edges.push({ from: aliases.get(parent) ?? sessionKey(parent), to: node.id, kind: 'child' });
+    }
+    for (const session of sessions) {
+        for (const check of stateFor(session.id)?.checks ?? []) {
+            if (session.archived && !activeCheck(check))
+                continue;
+            const id = `check:${session.id}:${check.id}`;
+            nodes.push({
+                id,
+                kind: 'check',
+                title: check.purpose,
+                tag: 'Check',
+                sessionId: session.id,
+                checkId: check.id,
+                checkActive: activeCheck(check),
+                status: check.state === 'succeeded'
+                    ? 'done'
+                    : check.state === 'awaiting_approval'
+                        ? 'attention'
+                        : activeCheck(check)
+                            ? 'running'
+                            : 'failed',
+                statusLabel: check.state.replaceAll('_', ' '),
+                description: check.command,
+                reason: `${check.startedAt ? 'Ran in mutable workspace.' : 'Mutable workspace; startup not yet confirmed.'} ${check.reason ?? 'No revision verification or task completion implied.'}`,
+            });
+            const origin = check.taskId &&
+                nodes.find((n) => n.kind === 'task' && n.coordinatorId === session.id && n.taskId === check.taskId)?.id;
+            edges.push({
+                from: origin || aliases.get(session.id) || sessionKey(session.id),
+                to: id,
+                kind: 'child',
+            });
+        }
+    }
+    const ids = new Set(nodes.map((node) => node.id));
+    return { nodes, edges: edges.filter((edge) => ids.has(edge.from) && ids.has(edge.to)) };
+}

package/dist/apps/server/src/task-logs.js

@@ -0,0 +1,74 @@
+/** Retain recent output and tool metadata without copying arbitrary event payloads. */
+export function taskLogs(events) {
+    let textBudget = 16000;
+    let argsBudget = 16000;
+    let traceBudget = 64000;
+    return events
+        .filter((event) => (event.text || event.toolName || event.type.startsWith('tool_')) &&
+        !['command', 'task_progress'].includes(event.type))
+        .slice(-40)
+        .reverse()
+        .flatMap((event) => {
+        // Exhausting output must not discard earlier tool identities/history.
+        const text = textBudget ? event.text?.slice(-Math.min(2000, textBudget)) : '';
+        textBudget -= text?.length ?? 0;
+        const source = event.data;
+        const data = {};
+        if (event.text && text !== event.text)
+            data.textTruncated = true;
+        if ([
+            'shell_evaluation_request',
+            'session_routing_request',
+            'jev_task_routing_request',
+            'jev_shell_safety_request',
+            'jev_agent_consult_request',
+        ].includes(event.type) &&
+            source?.request) {
+            const serialized = JSON.stringify(source.request);
+            if (serialized.length <= traceBudget) {
+                data.request = JSON.parse(serialized);
+                traceBudget -= serialized.length;
+            }
+        }
+        if (typeof source?.toolCallId === 'string' && source.toolCallId.length <= 200)
+            data.toolCallId = source.toolCallId;
+        if (typeof source?.isError === 'boolean')
+            data.isError = source.isError;
+        if (source?.args != null) {
+            const serialized = JSON.stringify(source.args);
+            if (serialized.length <= Math.min(4000, argsBudget)) {
+                data.args = JSON.parse(serialized);
+                data.argsTruncated = false;
+                argsBudget -= serialized.length;
+            }
+            else {
+                data.argsTruncated = true;
+                const args = source.args;
+                const summary = {};
+                for (const key of ['path', 'file', 'command', 'query', 'pattern', 'side', 'title']) {
+                    const value = args[key];
+                    if (typeof value === 'string' &&
+                        value.length <= 500 &&
+                        value.length + 32 <= argsBudget) {
+                        summary[key] = value;
+                        argsBudget -= value.length + 32;
+                    }
+                }
+                if (Object.keys(summary).length)
+                    data.args = summary;
+            }
+        }
+        return [
+            {
+                seq: event.seq,
+                runId: event.runId,
+                type: event.type,
+                toolName: event.toolName,
+                createdAt: event.createdAt,
+                text,
+                ...(Object.keys(data).length ? { data } : {}),
+            },
+        ];
+    })
+        .reverse();
+}

package/dist/apps/server/src/task-numbers.js

@@ -0,0 +1,25 @@
+/** Stable labels shared by proposals and directly started work within one coordinator session. */
+export function createTaskNumbers(store) {
+    const numbers = store.get('taskDisplayNumbers') ?? {};
+    const nextByCoordinator = new Map();
+    for (const [storedKey, number] of Object.entries(numbers)) {
+        try {
+            const parsed = JSON.parse(storedKey);
+            if (Array.isArray(parsed) && parsed.length === 2 && typeof parsed[0] === 'string')
+                nextByCoordinator.set(parsed[0], Math.max(nextByCoordinator.get(parsed[0]) ?? 0, number));
+        }
+        catch {
+            // Legacy project-wide keys are retained, but do not advance new session-local counters.
+        }
+    }
+    return (coordinatorId, itemId, preferred) => {
+        const key = JSON.stringify([coordinatorId, itemId]);
+        if (Object.hasOwn(numbers, key))
+            return numbers[key];
+        const next = Math.max(nextByCoordinator.get(coordinatorId) ?? 0, preferred ?? 0);
+        numbers[key] = preferred ?? next + 1;
+        nextByCoordinator.set(coordinatorId, Math.max(next, numbers[key]));
+        store.put('taskDisplayNumbers', numbers);
+        return numbers[key];
+    };
+}