agy-mcp-bridge 0.1.21 → 0.1.22

package/dist/src/missions/missions.js

@@ -0,0 +1,413 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import * as z from 'zod/v4';
+import { delegateSchema } from '../security/input.js';
+import { validateWorkspace } from '../security/workspace.js';
+import { redact } from '../security/redact.js';
+/**
+ * A mission is a plan the bridge records and enforces but never runs by itself: an MCP client (the orchestrator)
+ * dispatches one step at a time and waits on the returned task with the existing task tools. Keeping the plan here
+ * rather than only in the client's context is what makes it survive a reconnect or a restart, and gating dispatch on
+ * the recorded dependencies is what stops a worker being sent at a step whose inputs do not exist yet.
+ */
+export const MAX_STEPS_PER_MISSION = 12;
+/** Bound the record itself: an MCP request body is capped at 131072 bytes, and the whole plan is re-read by every status call. */
+export const MAX_MISSION_CHARACTERS = 100_000;
+/** Oldest missions with no task still in flight are dropped first, exactly like finished tasks. */
+export const MAX_RETAINED_MISSIONS = 20;
+const stepIdValue = z.string().regex(/^[a-z0-9][a-z0-9._-]{0,63}$/, 'step_id must be a lowercase slug: a-z, 0-9, dot, dash or underscore, at most 64 characters, starting with a letter or digit');
+export const stepIdSchema = stepIdValue;
+export const missionStepSchema = z.object({
+    step_id: stepIdValue,
+    title: z.string().trim().min(1).max(200),
+    depends_on: z.array(stepIdValue).max(MAX_STEPS_PER_MISSION).default([]),
+    /** Everything the step will be delegated with, validated by the same schema a direct call has to pass. */
+    delegate: delegateSchema
+}).strict();
+const stepsSchema = z.array(missionStepSchema).min(1).max(MAX_STEPS_PER_MISSION);
+export const missionCreateSchema = z.object({
+    title: z.string().trim().min(1).max(200),
+    goal: z.string().trim().min(1).max(4000),
+    workspace: z.string().min(1).max(4096),
+    steps: stepsSchema
+}).strict();
+/** The plan is append-only: a new attempt is a new step, never an edit of a step that already ran. */
+export const missionExtendSchema = z.object({ mission_id: z.uuid(), steps: stepsSchema }).strict();
+export const missionIdSchema = z.object({ mission_id: z.uuid() }).strict();
+export const missionDispatchSchema = z.object({ mission_id: z.uuid(), step_id: stepIdValue }).strict();
+export const missionCancelSchema = z.object({ mission_id: z.uuid(), cancel_running_tasks: z.boolean().optional() }).strict();
+const MISSION_FILE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.json$/;
+/** Disk records are validated on the way in: a foreign or half-written file is skipped, never trusted. */
+const recordSchema = z.object({
+    mission: z.object({
+        mission_id: z.uuid(), title: z.string(), goal: z.string(), workspace: z.string(),
+        status: z.enum(['open', 'canceled']), client: z.string().nullable(),
+        created_at: z.string(), updated_at: z.string(), canceled_at: z.string().nullable(),
+        steps: z.array(z.object({
+            step_id: stepIdValue, title: z.string(), depends_on: z.array(z.string()),
+            task_id: z.string().nullable(), delegate: delegateSchema
+        }).strict())
+    }).strict()
+}).strict();
+/**
+ * Structural rules of a plan, checked before anything is written. They cannot be expressed as per-field zod checks
+ * because they span steps, and a mission failing them could never be dispatched correctly.
+ */
+export function assertPlan(additions, existing, workspace, maxTimeoutSeconds) {
+    const ids = new Set(existing.map(step => step.step_id));
+    for (const step of additions) {
+        if (ids.has(step.step_id))
+            throw new Error(`step_id "${step.step_id}" is already in the plan; the plan is append-only, so a retry needs a new step_id`);
+        ids.add(step.step_id);
+    }
+    const all = [...existing, ...additions];
+    const known = new Set(all.map(step => step.step_id));
+    for (const step of additions) {
+        if (step.delegate.workspace !== workspace)
+            throw new Error(`step "${step.step_id}" asks for workspace ${JSON.stringify(step.delegate.workspace)}, but a mission runs entirely in ${JSON.stringify(workspace)}`);
+        if (new Set(step.depends_on).size !== step.depends_on.length)
+            throw new Error(`step "${step.step_id}" lists the same dependency twice`);
+        if (step.depends_on.includes(step.step_id))
+            throw new Error(`step "${step.step_id}" depends on itself`);
+        for (const dependency of step.depends_on)
+            if (!known.has(dependency))
+                throw new Error(`step "${step.step_id}" depends on "${dependency}", which is not in the plan`);
+        if (step.delegate.timeout_seconds !== undefined && step.delegate.timeout_seconds > maxTimeoutSeconds)
+            throw new Error(`step "${step.step_id}" asks for ${step.delegate.timeout_seconds}s but the bridge limit is ${maxTimeoutSeconds}s`);
+    }
+    const cycle = findCycle(all);
+    if (cycle)
+        throw new Error(`dependency cycle: ${cycle.join(' -> ')}`);
+    const size = JSON.stringify(all).length;
+    if (size > MAX_MISSION_CHARACTERS)
+        throw new Error(`the plan would be ${size} characters, over the ${MAX_MISSION_CHARACTERS} limit; split the mission or shorten the steps`);
+}
+/** Iterative DFS over the dependency graph; returns the cycle it found, or null. */
+function findCycle(steps) {
+    const edges = new Map(steps.map(step => [step.step_id, step.depends_on]));
+    const done = new Set();
+    const onStack = new Set();
+    const stack = [];
+    for (const root of edges.keys()) {
+        if (done.has(root))
+            continue;
+        stack.push({ id: root, index: 0 });
+        onStack.add(root);
+        while (stack.length) {
+            const frame = stack[stack.length - 1];
+            const children = edges.get(frame.id) ?? [];
+            if (frame.index >= children.length) {
+                stack.pop();
+                onStack.delete(frame.id);
+                done.add(frame.id);
+                continue;
+            }
+            const child = children[frame.index++];
+            if (done.has(child) || !edges.has(child))
+                continue;
+            if (onStack.has(child))
+                return [...stack.map(entry => entry.id), child];
+            stack.push({ id: child, index: 0 });
+            onStack.add(child);
+        }
+    }
+    return null;
+}
+const redactedDelegate = (delegate) => ({
+    ...delegate,
+    task: redact(delegate.task),
+    acceptance_criteria: delegate.acceptance_criteria.map(redact),
+    ...(delegate.context === undefined ? {} : { context: redact(delegate.context) })
+});
+const toSteps = (inputs) => inputs.map(step => ({ step_id: step.step_id, title: redact(step.title), depends_on: [...step.depends_on], task_id: null, delegate: redactedDelegate(step.delegate) }));
+export class MissionManager {
+    tasks;
+    config;
+    missions = new Map();
+    /** Steps whose dispatch call is in flight. Delegation is asynchronous, so without this two concurrent calls could both pass the readiness check. */
+    inFlight = new Set();
+    /** A plan only needs the workspace allowlist and the timeout ceiling; the task manager owns everything else. */
+    constructor(tasks, config) {
+        this.tasks = tasks;
+        this.config = config;
+    }
+    get stateDirectory() { return this.tasks.stateDirectory; }
+    get missionsDirectory() { return path.join(this.tasks.stateDirectory, 'missions'); }
+    async create(raw, meta = {}) {
+        const input = missionCreateSchema.parse(raw);
+        assertPlan(input.steps, [], input.workspace, this.config.max_timeout_seconds);
+        // Fail at the plan rather than at the first dispatch: a workspace outside the allowlist can never run a step.
+        const workspace = await validateWorkspace(input.workspace, this.config.allowed_workspaces);
+        // One spelling for the whole record. `assertPlan` proved every step names the mission's workspace, so rewriting
+        // it to the canonical directory loses nothing — and keeping the raw string would make `mission_plan` print two
+        // spellings of one directory, which `extend` would then refuse the client for using.
+        const steps = input.steps.map(step => ({ ...step, delegate: { ...step.delegate, workspace } }));
+        const now = new Date().toISOString();
+        const mission = {
+            mission_id: randomUUID(), title: redact(input.title), goal: redact(input.goal), workspace,
+            status: 'open', client: meta.client ? redact(meta.client).slice(0, 100) : null,
+            created_at: now, updated_at: now, canceled_at: null, steps: toSteps(steps)
+        };
+        this.missions.set(mission.mission_id, mission);
+        for (const evicted of this.makeRoom())
+            await this.forget(evicted);
+        await this.persist(mission);
+        return mission;
+    }
+    /** Add steps to a plan that is still open. Existing steps are never rewritten. */
+    async extend(id, steps) {
+        const mission = this.require(id);
+        if (mission.status === 'canceled')
+            throw new Error(`mission ${id} is canceled; its plan can no longer change`);
+        const additions = await this.alignWorkspaces(stepsSchema.parse(steps), mission.workspace);
+        assertPlan(additions, mission.steps, mission.workspace, this.config.max_timeout_seconds);
+        mission.steps.push(...toSteps(additions));
+        mission.updated_at = new Date().toISOString();
+        await this.persist(mission);
+        return mission;
+    }
+    /**
+     * Resolve each distinct workspace spelling of an incoming plan against the mission's own directory, so the
+     * single-workspace rule gates on the directory rather than on how the client wrote it: a trailing separator,
+     * slashes the other way or a Windows short name all name a workspace the plan already runs in, and `dispatch`
+     * canonicalizes the same string anyway. Only a spelling that lands on this mission's directory is rewritten;
+     * anything else stays exactly as the client wrote it so `assertPlan` refuses it with the plan's own message.
+     */
+    async alignWorkspaces(steps, workspace) {
+        const lands = new Map();
+        for (const candidate of new Set(steps.map(step => step.delegate.workspace))) {
+            if (candidate === workspace) {
+                lands.set(candidate, true);
+                continue;
+            }
+            const resolved = await validateWorkspace(candidate, this.config.allowed_workspaces).catch(() => null);
+            lands.set(candidate, resolved === workspace);
+        }
+        return steps.map(step => lands.get(step.delegate.workspace) ? { ...step, delegate: { ...step.delegate, workspace } } : step);
+    }
+    /**
+     * Starts the one step the caller names, with the arguments recorded in its plan entry. The bridge never picks the
+     * next step itself: readiness is checked here, so a dependency that did not complete cannot be skipped past.
+     */
+    async dispatch(missionId, stepId, meta = {}) {
+        const mission = this.require(missionId);
+        const step = mission.steps.find(item => item.step_id === stepId);
+        if (!step)
+            throw new Error(`mission ${missionId} has no step "${stepId}"`);
+        if (mission.status === 'canceled')
+            throw new Error(`mission ${missionId} is canceled: no step can be dispatched`);
+        const states = this.states(mission);
+        if (step.task_id)
+            throw new Error(`step "${stepId}" is already bound to task ${step.task_id} (${states.get(stepId)}); the plan is append-only, so dispatch a new step to try again`);
+        const unmet = step.depends_on.filter(dependency => states.get(dependency) !== 'completed');
+        if (unmet.length)
+            throw new Error(`step "${stepId}" is not ready: ${unmet.map(dependency => `"${dependency}" is ${states.get(dependency)}`).join(', ')}`);
+        const key = `${missionId}/${stepId}`;
+        if (this.inFlight.has(key))
+            throw new Error(`step "${stepId}" is already being dispatched by another call`);
+        this.inFlight.add(key);
+        try {
+            const task = await this.tasks.delegate({ ...step.delegate }, { client: meta.client ?? `mission ${missionId}/${stepId}` });
+            step.task_id = task.task_id;
+            mission.updated_at = new Date().toISOString();
+            await this.persist(mission);
+            return { mission, step, task };
+        }
+        finally {
+            this.inFlight.delete(key);
+        }
+    }
+    /**
+     * Stops the plan: nothing further can be dispatched. Running agents are left alone unless asked, because stopping a
+     * process mid-edit is the caller's decision and `antigravity_cancel_task` is the tool for it.
+     */
+    async cancel(id, options = {}) {
+        const mission = this.require(id);
+        const states = this.states(mission);
+        const running = mission.steps
+            .filter(step => step.task_id && (states.get(step.step_id) === 'queued' || states.get(step.step_id) === 'running'))
+            .map(step => step.task_id);
+        const canceled = [];
+        if (mission.status !== 'canceled') {
+            mission.status = 'canceled';
+            mission.canceled_at = new Date().toISOString();
+            mission.updated_at = mission.canceled_at;
+            await this.persist(mission);
+        }
+        // Asking for the agents to stop is a separate decision from closing the plan, so it stays honoured after a first cancel.
+        if (options.cancelRunningTasks) {
+            for (const taskId of running) {
+                const stopped = await this.tasks.cancel(taskId).catch(() => undefined);
+                if (stopped?.status === 'canceled')
+                    canceled.push(taskId);
+            }
+        }
+        return { mission, running, canceled };
+    }
+    /** Cheap progress view: no task text and no logs, one short entry per step. */
+    view(id) { return this.viewOf(this.require(id), false); }
+    /** The whole plan with each step's delegate arguments, for an orchestrator that has lost its own copy. */
+    planOf(id) { return this.viewOf(this.require(id), true); }
+    list() {
+        return [...this.missions.values()]
+            .map(mission => this.viewOf(mission, false))
+            .sort((a, b) => Date.parse(b.updated_at) - Date.parse(a.updated_at));
+    }
+    overview() {
+        let open = 0, canceled = 0, steps = 0, ready = 0;
+        for (const mission of this.missions.values()) {
+            mission.status === 'open' ? open++ : canceled++;
+            const view = this.viewOf(mission, false);
+            steps += view.progress.total;
+            ready += view.ready.length;
+        }
+        return { open, canceled, steps, ready };
+    }
+    require(id) {
+        const mission = this.missions.get(id);
+        if (!mission)
+            throw new Error('Unknown or expired mission_id');
+        return mission;
+    }
+    /**
+     * Task-derived state for a bound step, then readiness for the rest. A step can only reach `completed` through its
+     * own task, so an unbound dependency never satisfies readiness and one pass settles every state.
+     */
+    states(mission) {
+        const states = new Map();
+        for (const step of mission.steps) {
+            if (!step.task_id)
+                continue;
+            try {
+                states.set(step.step_id, this.tasks.summary(step.task_id).status);
+            }
+            catch {
+                states.set(step.step_id, 'lost');
+            }
+        }
+        for (const step of mission.steps) {
+            if (states.has(step.step_id))
+                continue;
+            states.set(step.step_id, step.depends_on.some(dependency => states.get(dependency) !== 'completed') ? 'pending' : 'ready');
+        }
+        return states;
+    }
+    viewOf(mission, withArgs) {
+        const states = this.states(mission);
+        const steps = mission.steps.map(step => {
+            const state = states.get(step.step_id);
+            const summary = step.task_id ? this.summaryOrNull(step.task_id) : null;
+            return {
+                step_id: step.step_id, title: step.title, state, depends_on: [...step.depends_on],
+                blocked_by: state === 'pending'
+                    ? step.depends_on.filter(dependency => states.get(dependency) !== 'completed').map(dependency => ({ step_id: dependency, state: states.get(dependency) }))
+                    : [],
+                task_id: step.task_id, agent: step.delegate.agent ?? null, isolation: step.delegate.isolation,
+                scope: summary?.scope ? { checked: summary.scope.checked, changed: summary.scope.changed, out_of_scope: summary.scope.out_of_scope.length } : null,
+                ...(withArgs ? { delegate: step.delegate } : {})
+            };
+        });
+        const count = (test) => steps.filter(step => test(step.state)).length;
+        const terminal = (state) => state !== 'completed' && state !== 'ready' && state !== 'pending' && state !== 'queued' && state !== 'running';
+        return {
+            mission_id: mission.mission_id, title: mission.title, workspace: mission.workspace, status: mission.status,
+            created_at: mission.created_at, updated_at: mission.updated_at,
+            ...(withArgs ? { goal: mission.goal, client: mission.client } : {}),
+            progress: {
+                total: steps.length,
+                completed: count(state => state === 'completed'),
+                active: count(state => state === 'queued' || state === 'running'),
+                ready: count(state => state === 'ready'),
+                pending: count(state => state === 'pending'),
+                unmet: count(terminal)
+            },
+            ready: steps.filter(step => step.state === 'ready').map(step => step.step_id),
+            steps
+        };
+    }
+    summaryOrNull(id) {
+        try {
+            return this.tasks.summary(id);
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Retention only ever releases a mission with no task in flight, so a plan cannot vanish under a running agent. */
+    makeRoom() {
+        const evicted = [];
+        while (this.missions.size > MAX_RETAINED_MISSIONS) {
+            const candidates = [...this.missions.values()]
+                .filter(mission => {
+                const states = this.states(mission);
+                return ![...states.values()].some(state => state === 'queued' || state === 'running');
+            })
+                .sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at));
+            if (!candidates.length)
+                return evicted;
+            const [oldest] = candidates;
+            this.missions.delete(oldest.mission_id);
+            evicted.push(oldest.mission_id);
+            console.error(`[bridge] Dropped the oldest mission record ${oldest.mission_id} to keep ${MAX_RETAINED_MISSIONS} missions`);
+        }
+        return evicted;
+    }
+    /** Best effort, like task history: a lost write costs the resume, not the running plan. */
+    async persist(mission) {
+        const file = path.join(this.missionsDirectory, `${mission.mission_id}.json`);
+        try {
+            await mkdir(this.missionsDirectory, { recursive: true, mode: 0o700 });
+            await writeFile(`${file}.tmp`, JSON.stringify({ mission }), { mode: 0o600 });
+            // The web UI and a polling client open these records for reading; Windows refuses a rename onto a held file.
+            for (let attempt = 0;; attempt++) {
+                try {
+                    await rename(`${file}.tmp`, file);
+                    break;
+                }
+                catch (error) {
+                    const code = error.code;
+                    if (attempt >= 2 || (code !== 'EPERM' && code !== 'EACCES' && code !== 'EBUSY'))
+                        throw error;
+                    await new Promise(resolve => setTimeout(resolve, 50 * (attempt + 1)));
+                }
+            }
+        }
+        catch {
+            await unlink(`${file}.tmp`).catch(() => undefined);
+        }
+    }
+    async forget(id) {
+        await unlink(path.join(this.missionsDirectory, `${id}.json`)).catch(() => undefined);
+    }
+    /**
+     * Reloads plans after a restart. Step state is derived from the task records on every read rather than stored, so a
+     * task that the restart marked failed shows up as failed here too, and no step is ever re-dispatched on its own.
+     */
+    async restore() {
+        let names;
+        try {
+            names = (await readdir(this.missionsDirectory)).filter(name => MISSION_FILE.test(name));
+        }
+        catch {
+            return 0;
+        }
+        const loaded = [];
+        for (const name of names) {
+            try {
+                const { mission } = recordSchema.parse(JSON.parse(await readFile(path.join(this.missionsDirectory, name), 'utf8')));
+                if (`${mission.mission_id}.json` !== name)
+                    continue;
+                loaded.push(mission);
+            }
+            catch { /* a record this project did not write is left where it is, never loaded */ }
+        }
+        loaded.sort((a, b) => Date.parse(b.created_at) - Date.parse(a.created_at));
+        for (const mission of loaded.slice(MAX_RETAINED_MISSIONS))
+            await this.forget(mission.mission_id);
+        for (const mission of loaded.slice(0, MAX_RETAINED_MISSIONS))
+            this.missions.set(mission.mission_id, mission);
+        return this.missions.size;
+    }
+}
+//# sourceMappingURL=missions.js.map

package/dist/src/onboarding.js

@@ -22,8 +22,8 @@ export function skillPromptDisabled(env = process.env) {
     return /^(1|true|yes)$/i.test(env.BRIDGE_NO_SKILL_PROMPT ?? '') || /^(1|true)$/i.test(env.CI ?? '');
 }
 /**
- * Offers, once, to install the antigravity-bridge skill for Codex / Claude Code. Nothing is written without an explicit answer:
- * it only asks in an interactive terminal, only for clients that have no skill file yet (a customized file is never touched),
+ * Offers, once, to install the skills this bridge ships for Codex / Claude Code. Nothing is written without an explicit answer:
+ * it only asks in an interactive terminal, only for clients that have no file yet for some skill (a customized file is never touched),
  * and the answer, including "no", is remembered so the question is not repeated. It never throws and never blocks the server.
  */
 export async function offerSkillInstall(options) {
@@ -39,19 +39,22 @@ export async function offerSkillInstall(options) {
     catch {
         return 'skipped';
     }
-    const clients = ['codex', 'claude'].filter(client => status[client].state === 'missing');
+    const missing = (client) => status[client].filter(entry => entry.state === 'missing');
+    const clients = ['codex', 'claude'].filter(client => missing(client).length > 0);
     if (!clients.length)
         return 'skipped';
-    log('[skill] The antigravity-bridge skill tells Codex / Claude Code how to delegate to Antigravity safely and how to review the result.');
+    log('[skill] These skills tell Codex / Claude Code how to delegate to the bridge agents safely and how to review the result.');
     for (const client of clients)
-        log(`[skill]   ${client}: would be written to ${status[client].file}`);
+        for (const entry of missing(client))
+            log(`[skill]   ${client}: ${entry.skill} would be written to ${entry.file}`);
     for (const client of ['codex', 'claude'])
-        if (status[client].state === 'different')
-            log(`[skill]   ${client}: a customized skill already exists and will not be touched (${status[client].file})`);
+        for (const entry of status[client])
+            if (entry.state === 'different')
+                log(`[skill]   ${client}: a customized ${entry.skill} skill already exists and will not be touched (${entry.file})`);
     const choices = [...clients, ...(clients.length > 1 ? ['both'] : [])].join(' / ');
     let selected = null;
     for (let attempt = 0; attempt < 2 && selected === null; attempt++) {
-        const answer = (await options.ask(`Install it now? [${choices} / N] `)).trim().toLowerCase();
+        const answer = (await options.ask(`Install them now? [${choices} / N] `)).trim().toLowerCase();
         if (answer === '' || answer === 'n' || answer === 'no') {
             await remember(options.stateDirectory, { skill_offer: { answered_at: new Date((options.now ?? Date.now)()).toISOString(), choice: 'declined' } });
             log('[skill] Not installed, and this question will not be asked again. Install later with: agy-mcp-bridge skill install --client both');
@@ -67,21 +70,24 @@ export async function offerSkillInstall(options) {
     if (!selected)
         return 'skipped';
     try {
-        for (const client of selected)
-            for (const item of await (options.install ?? installSkill)({ client, userHome: options.userHome }))
+        // Only the skills that are actually absent for that client: a customized file is never part of the request.
+        for (const client of selected) {
+            const skills = missing(client).map(entry => entry.skill);
+            for (const item of await (options.install ?? installSkill)({ client, userHome: options.userHome, skills }))
                 log(`[skill] ${item.unchanged ? 'Already installed' : item.updated ? 'Updated' : 'Installed'}: ${item.filename}`);
+        }
     }
     catch (error) {
         log(`[skill] Could not install: ${error instanceof Error ? error.message : 'unknown error'}. The server starts anyway; try again with: agy-mcp-bridge skill install --client both`);
         return 'failed';
     }
     await remember(options.stateDirectory, { skill_offer: { answered_at: new Date((options.now ?? Date.now)()).toISOString(), choice: selected.join('+') } });
-    log('[skill] Reopen the client if the skill does not appear. MCP connection and workspace permissions are configured separately (agy-mcp-bridge setup).');
+    log('[skill] Reopen the client if a skill does not appear. MCP connection and workspace permissions are configured separately (agy-mcp-bridge setup).');
     return 'installed';
 }
 /**
  * Offers to replace an installed skill that is an older version this project shipped. A file that matches no shipped version is the
- * owner's own edit and is neither offered nor touched. The answer, including "no", is remembered for the current packaged skill, so the
+ * owner's own edit and is neither offered nor touched. The answer, including "no", is remembered for the packaged set as it is now, so the
  * question comes back only when a newer skill ships. Same rules as the install offer: interactive terminals only, never throws.
  */
 export async function offerSkillUpdate(options) {
@@ -95,16 +101,18 @@ export async function offerSkillUpdate(options) {
     catch {
         return 'skipped';
     }
-    const outdated = ['codex', 'claude'].filter(client => status[client].state === 'outdated');
+    const outdatedFor = (client) => status[client].filter(entry => entry.state === 'outdated');
+    const outdated = ['codex', 'claude'].filter(client => outdatedFor(client).length > 0);
     if (!outdated.length)
         return 'skipped';
     const previous = (await readRecord(options.stateDirectory)).skill_update_offer;
     if (previous?.hash === status.currentHash)
         return 'skipped';
     const when = () => new Date((options.now ?? Date.now)()).toISOString();
-    log('[skill] A newer antigravity-bridge skill ships with this bridge. These installed copies are older packaged versions (not edited by you):');
+    log('[skill] Newer skills ship with this bridge. These installed copies are older packaged versions (not edited by you):');
     for (const client of outdated)
-        log(`[skill]   ${client}: ${status[client].file}`);
+        for (const entry of outdatedFor(client))
+            log(`[skill]   ${client}: ${entry.skill} at ${entry.file}`);
     let yes = false;
     for (let attempt = 0; attempt < 2 && !yes; attempt++) {
         const answer = (await options.ask('Update them now? [y / N] ')).trim().toLowerCase();
@@ -121,9 +129,11 @@ export async function offerSkillUpdate(options) {
     if (!yes)
         return 'skipped';
     try {
-        for (const client of outdated)
-            for (const item of await (options.install ?? installSkill)({ client, userHome: options.userHome, update: true }))
+        for (const client of outdated) {
+            const skills = outdatedFor(client).map(entry => entry.skill);
+            for (const item of await (options.install ?? installSkill)({ client, userHome: options.userHome, update: true, skills }))
                 log(`[skill] ${item.unchanged ? 'Already up to date' : item.updated ? 'Updated' : 'Installed'}: ${item.filename}`);
+        }
     }
     catch (error) {
         log(`[skill] Could not update: ${error instanceof Error ? error.message : 'unknown error'}. The server starts anyway; try again with: agy-mcp-bridge skill install --client both --update`);

package/dist/src/runtime.js

@@ -3,6 +3,7 @@ import { helperDirectory, paths } from './paths.js';
 import { inspectCli, resolveCommand, startProcess, VERIFIED_AGY_VERSIONS } from './antigravity/process.js';
 import { createAgentRegistry, publicAgents } from './agents/registry.js';
 import { TaskManager } from './tasks/manager.js';
+import { MissionManager, MAX_RETAINED_MISSIONS, MAX_STEPS_PER_MISSION } from './missions/missions.js';
 import { sweepStaleWorktrees, pruneWorktrees } from './isolation/worktree.js';
 import { startTreeWatch } from './isolation/orphans.js';
 import { recoverExecutionLock } from './tasks/execution-lock.js';
@@ -56,6 +57,11 @@ export async function createRuntime() {
     const restored = await manager.restore();
     if (restored)
         console.error(`[bridge] Restored ${restored} finished task record(s) from .bridge-state/tasks`);
+    // Mission step state is read from the task records above, so restoring plans afterwards costs nothing and cannot disagree with them.
+    const missions = new MissionManager(manager, config);
+    const restoredMissions = await missions.restore();
+    if (restoredMissions)
+        console.error(`[bridge] Restored ${restoredMissions} mission plan(s) from .bridge-state/missions (no step is dispatched by itself)`);
     const lockWarning = await manager.lockDiagnostic();
     if (lockWarning)
         console.error(`[bridge] WARNING: ${lockWarning}`);
@@ -69,17 +75,19 @@ export async function createRuntime() {
         default_agent: registry.defaultAgent,
         max_parallel_worktrees: maxParallelWorktrees,
         default_autonomy: config.default_autonomy ?? 'auto',
-        supported: { delegate: anyAgent, status: true, wait: true, output: true, cancel_owned_process: true, agents_list: true, worktree_isolation: true, detached_resume: false },
+        supported: { delegate: anyAgent, status: true, wait: true, output: true, cancel_owned_process: true, agents_list: true, worktree_isolation: true, missions: true, detached_resume: false },
         allowed_workspaces: config.allowed_workspaces, session_workspaces: sessionOnlyWorkspaces(),
         authentication: 'Each agent CLI uses its own cached login; only a live task verifies it.',
-        limits: { max_timeout_seconds: config.max_timeout_seconds, max_output_bytes_per_stream: config.max_output_bytes, max_retained_tasks: config.max_retained_tasks, concurrent_tasks: maxParallelWorktrees + 1, concurrent_normal_tasks: 1, max_parallel_worktrees: maxParallelWorktrees, max_queued_tasks: config.max_queued_tasks },
+        limits: { max_timeout_seconds: config.max_timeout_seconds, max_output_bytes_per_stream: config.max_output_bytes, max_retained_tasks: config.max_retained_tasks, max_mission_steps: MAX_STEPS_PER_MISSION, max_retained_missions: MAX_RETAINED_MISSIONS, concurrent_tasks: maxParallelWorktrees + 1, concurrent_normal_tasks: 1, max_parallel_worktrees: maxParallelWorktrees, max_queued_tasks: config.max_queued_tasks },
         limitations: [
             `Antigravity requires agy 1.4.x with all required flags; real execution was verified on ${VERIFIED_AGY_VERSIONS.join(' and ')}.`,
             'Codex runs non-interactively with sandbox workspace-write; approval-requiring actions still fail instead of bypassing the sandbox.',
             'Ordinary tasks are serialized globally. Only tasks with isolation "worktree" run concurrently, each in its own git worktree and branch.',
+            'Mission plans are recorded and gated by the bridge, but the bridge never dispatches a step by itself: every step starts on a client call, and a canceled or completed plan grants nothing.',
             'Worktree tasks declare owns; files outside that list are reported for review and are never merged automatically.',
             ...antigravity.warnings,
             'Client disconnect does not cancel accepted tasks. Finished-task records persist in .bridge-state/tasks; a task running during a restart is marked failed and its process is not recovered.',
+            'Mission plans persist in .bridge-state/missions across restarts, with the step states read back from those task records. The bridge does not re-dispatch anything after a restart.',
             'CLI SUCCESS/exit 0 does not establish acceptance; tool permissions may have been denied.',
             'Workspace preflight is not an OS sandbox and cannot prevent concurrent link swaps.',
             'Existing agent permissions, hooks, MCP and credential access remain governed by each CLI configuration.',
@@ -90,6 +98,6 @@ export async function createRuntime() {
             'Redaction recognizes known patterns only. Never include credentials in task data.'
         ]
     };
-    return { manager, environment };
+    return { manager, missions, environment };
 }
 //# sourceMappingURL=runtime.js.map

package/dist/src/stdio.js

@@ -2,8 +2,8 @@ import { serveStdio } from '@modelcontextprotocol/server/stdio';
 import { createRuntime } from './runtime.js';
 import { createServer } from './tools/register.js';
 async function main() {
-    const { manager, environment } = await createRuntime();
-    const handle = serveStdio(() => createServer(manager, { ...environment, transport: 'stdio' }), { onerror: () => console.error('[bridge] MCP transport error') });
+    const { manager, missions, environment } = await createRuntime();
+    const handle = serveStdio(() => createServer(manager, { ...environment, transport: 'stdio' }, missions), { onerror: () => console.error('[bridge] MCP transport error') });
     let shuttingDown = false;
     const shutdown = async () => {
         if (shuttingDown)