@ctrl-spc/cs 0.7.11 → 0.7.13

package/dist/panel3/spawn.js

@@ -322,6 +322,15 @@ export function codexAnswer(stdout, exitCode = 0, stderr = '') {
         }
     }
     if (failure !== null) {
+        // Codex wraps provider errors in turn.failed.error.message. A rejected
+        // request cannot recover by sending the same model and effort again.
+        try {
+            const provider = JSON.parse(failure);
+            if (provider?.status === 400 && provider?.error?.type === 'invalid_request_error') {
+                return { ok: false, reason: `codex could not finish the turn: ${provider.error.message ?? failure}`, retryable: false };
+            }
+        }
+        catch { /* Ordinary native failure text keeps the existing recovery policy. */ }
         return { ok: false, reason: `codex could not finish the turn${failure ? `: ${failure}` : ''}` };
     }
     if (exitCode !== 0) {
@@ -332,6 +341,17 @@ export function codexAnswer(stdout, exitCode = 0, stderr = '') {
     }
     return { ok: true, text: text.trim() };
 }
+/** Claude prints provider/model rejections on stdout, even with a nonzero exit. */
+export function claudeAnswer(stdout, exitCode = 0, stderr = '') {
+    if (/^\[claude-code:unrecognized_model\]/m.test(stdout + '\n' + stderr)) {
+        return { ok: false, retryable: false, reason: 'Claude rejected the selected model. Choose an available model and retry.' };
+    }
+    if (exitCode !== 0)
+        return { ok: false, reason: `claude exited ${exitCode}${tail(stderr) || tail(stdout)}` };
+    if (stdout.trim() === '')
+        return { ok: false, reason: `claude exited 0 and said nothing${tail(stderr)}` };
+    return { ok: true, text: stdout.trim() };
+}
 /** Enough for any answer a person reads, and a ceiling so a runaway process
  *  cannot exhaust this daemon's memory. */
 const MAX_OUTPUT_CHARS = 1_000_000;
@@ -547,22 +567,11 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings
                 // 'Reading prompt from stdin' on stderr, including on non-zero exits.
                 finish(codexAnswer(stdout, code ?? 1, stderr));
             }
-            else if (code !== 0) {
-                /* STDOUT WHEN STDERR IS EMPTY, because `claude -p` prints its own
-                   failure on stdout and exits non-zero having written nothing to
-                   stderr. Reporting only "exited 1" would throw away the one sentence
-                   that says what went wrong. */
-                finish({ ok: false, reason: `${agent} exited ${code}${tail(stderr) || tail(stdout)}` });
-            }
-            else if (stdout.trim() === '') {
-                finish({ ok: false, reason: `${agent} exited 0 and said nothing${tail(stderr)}` });
-            }
             else {
-                const text = stdout.trim();
-                finish({
-                    ok: true,
-                    text: truncated ? `${text}\n\n[cut off at ${MAX_OUTPUT_CHARS} characters]` : text,
-                });
+                const answer = claudeAnswer(stdout, code ?? 1, stderr);
+                finish(answer.ok && truncated
+                    ? { ...answer, text: `${answer.text}\n\n[cut off at ${MAX_OUTPUT_CHARS} characters]` }
+                    : answer);
             }
         });
         /* THE PROMPT, AND THEN END OF INPUT, because `claude -p` reads stdin to the

package/dist/panel3/tools.js

@@ -127,11 +127,12 @@ import { returned } from './client.js';
 import { readableWriteError, FIREWALL_WRITING_RULE } from '../firewall.js';
 import { rememberSecret, redactArgs } from './secrets.js';
 import { workBrief } from './prompt.js';
+import { listCodexModels } from './codex-models.js';
 /* The harness this daemon spawns with, which is the process this server runs
    in. It is what `panel3_runs.harness` is written from at spawn, so reading it
    here is the same fact without a second round trip. */
 import { harness } from './spawn.js';
-import { listCodebases } from '../codebases.js';
+import { listCodebases, listWorkItemCodebaseTargets, editWorkItemCodebaseTarget } from '../codebases.js';
 import { buildWorkflow, duplicateWorkflow, editWorkflow, readWorkflow, rewordStage, workflowToolPermission, validateWorkflowToolTarget, WORKFLOW_TOOL_TEACHING, WORKFLOW_AUTHORING_TEACHING } from '../workflows.js';
 /* ═══ 38-panel3-steps: THE FIFTH NEUTRAL MODULE, AND A DECISION LIKE THE OTHERS.
    ═══ Stages and steps are the work item's own record, shared by both
@@ -300,10 +301,9 @@ async function asked(caller, args, askPerson) {
         p_question: question,
         p_category: category,
         p_context: context,
-        /* Undefined, not a default: the defaults live in the function signature,
-           so there is one place that says what an unshaped question is. */
-        p_answer_mode: answer_mode,
-        p_options: options,
+        // Token-aware RPC overloads require these arguments, even for a free-text question.
+        p_answer_mode: answer_mode ?? 'free_text',
+        p_options: options ?? [],
         p_question_id: question_id ?? null,
         p_ask_person: askPerson,
         /* ═══ ONLY `ask_question` OFFERS THIS, AND THE DATABASE REFUSES IT ON AN
@@ -829,13 +829,14 @@ const TOOLS = [
         handler: async (caller, args) => productResult(await placeWorkItemHandler(caller.client, args)),
     },
     {
-        name: 'reorder_backlog', levels: [1],
+        name: 'reorder_backlog', levels: [1, 2],
         description: 'Move one backlog work item before another, or to the bottom. Read the current order first and explain the reason.',
         input: { project_id: z.string().uuid(), task_id: z.string().uuid(), before_task_id: z.string().uuid().optional(), reason: z.string().min(1) },
         handler: async (caller, args) => {
             const a = args;
             const items = await rows(caller.client.from('tasks').select('id, revision')
-                .eq('project_id', a.project_id).eq('status', 'backlog').is('archived_at', null).eq('is_idea', false).order('position').order('created_at').order('id'), 'read', 'the backlog');
+                .eq('project_id', a.project_id).eq('status', 'backlog').is('archived_at', null).eq('is_idea', false)
+                .in('id', a.before_task_id ? [a.task_id, a.before_task_id] : [a.task_id]), 'read', 'the backlog');
             const moving = items.find(item => item.id === a.task_id);
             if (!moving || (a.before_task_id && !items.some(item => item.id === a.before_task_id)))
                 throw new Error('Both items must be live backlog work in this project. Nothing was moved.');
@@ -963,32 +964,44 @@ const TOOLS = [
     {
         name: 'list_work_items',
         levels: ALL,
-        description: 'The work items (tasks) on the board, newest first. Optionally filtered to one project and one '
-            + 'status. Archived items and product ideas are not work items and are not listed.',
+        description: 'Live work items in saved manual board order, top to bottom within each project and status, '
+            + 'not creation order or a temporary UI sort. For backlog priority, pass project_id and status backlog. '
+            + 'Read all pages using next_offset until it is null before reporting the full order. Re-read after a reorder or a human change.',
         input: {
             project_id: z.string().optional().describe('Only items in this project.'),
             status: z.enum(['backlog', 'in_progress', 'done']).optional().describe('Only items in this status.'),
+            offset: z.number().int().min(0).default(0).describe('Use next_offset from the previous page; start at zero.'),
         },
         handler: async ({ client }, args) => {
-            const { project_id, status } = args;
+            const { project_id, status, offset = 0 } = args;
             let query = client
                 .from('tasks')
-                .select('id, name, status, project_id, epic_id, sprint_id, due_date, created_at')
+                .select('id, name, status, project_id, epic_id, sprint_id, due_date, position, created_at', { count: 'exact' })
                 .eq('is_idea', false)
                 .is('archived_at', null)
-                .order('created_at', { ascending: false });
+                .order('project_id').order('status').order('position').order('created_at').order('id');
             if (project_id)
                 query = query.eq('project_id', project_id);
             if (status)
                 query = query.eq('status', status);
-            const items = await rows(query, 'read', 'work items');
-            return listed(items.map((t) => line(t.id, t.status.padEnd(11), t.name, t.due_date ? `due ${t.due_date}` : null)), 'There are no work items matching that.');
+            const result = await query.range(offset, offset + 99);
+            const items = await rows(Promise.resolve(result), 'read', 'work items');
+            if (result.count === null)
+                throw new Error('Could not read the work-item total; the full order is unavailable.');
+            if (items.length === 0 && offset < result.count)
+                throw new Error('Work items changed while reading this page. Restart from offset zero.');
+            return JSON.stringify({
+                order: 'Saved manual board order, top to bottom within each project and status',
+                total: result.count,
+                next_offset: offset + items.length < result.count ? offset + items.length : null,
+                items,
+            });
         },
     },
     {
         name: 'get_work_item',
         levels: ALL,
-        description: 'One work item in full: its description, status, placement, and the artifacts on it.',
+        description: 'One work item in full: description, status, placement, saved codebase targets, available project codebases, and artifacts. Saved targets belong to the work item, not just this conversation.',
         input: { work_item_id: z.string() },
         handler: async ({ client }, args) => {
             const { work_item_id } = args;
@@ -1001,6 +1014,10 @@ const TOOLS = [
             const feedback = await rows(client.from('artifact_feedback').select('*').eq('task_id', work_item_id).order('created_at'), 'read', 'the artifact feedback');
             const decisions = await rows(client.from('decisions').select('id, category, question, state, selected_options, answer_note, related_artifact_id').eq('task_id', work_item_id).order('asked_at'), 'read', 'the work item decisions');
             const comments = await rows(client.from('comments').select('id, body, created_at').eq('task_id', work_item_id).order('created_at'), 'read', 'the work item comments');
+            const codebases = (await listCodebases(client, item.project_id))
+                .sort((a, b) => a.name.localeCompare(b.name))
+                .map(({ id, name, gitRemoteUrl }) => ({ id, name, git_remote_url: gitRemoteUrl }));
+            const targets = await listWorkItemCodebaseTargets(client, work_item_id);
             return [
                 `${item.name}`,
                 `id        ${item.id}`,
@@ -1009,6 +1026,8 @@ const TOOLS = [
                 `epic      ${item.epics?.name ?? 'none'}`,
                 `sprint    ${item.sprints?.name ?? 'none'}`,
                 `due       ${item.due_date ?? 'no date'}`,
+                'PROJECT CODEBASES', JSON.stringify(codebases),
+                'SAVED CODEBASE TARGETS', JSON.stringify(targets),
                 '',
                 'DESCRIPTION',
                 item.description.trim() === '' ? '(empty)' : item.description,
@@ -1165,10 +1184,15 @@ const TOOLS = [
                 `id        ${workflow.id}`,
                 `about     ${workflow.description.trim() === '' ? 'no description' : workflow.description}`,
                 '',
+                `ending    ${workflow.ending}`,
+                `BRANCH CONDITIONS  ${workflow.branches.length}`,
+                ...workflow.branches.map(branch => `if ${branch.when}, run workflow ${branch.runsWorkflowId}, then resume this workflow`),
+                '',
                 `STAGES  ${workflow.stages.length}`,
                 ...workflow.stages.flatMap((stage, i) => [
                     '',
                     line(`${i + 1}. ${stage.name}`, stage.description.trim() === '' ? null : stage.description),
+                    `stage_id  ${stage.id} (use stage number ${i + 1} for reword_stage and keep)`,
                     '',
                     /* THE WHOLE BODY. The body IS the stage document, so truncating it is
                        truncating the process. An empty one is a stage nobody has written
@@ -1191,8 +1215,9 @@ const TOOLS = [
                         '',
                     ]
                     : []),
-                'This is a WORKFLOW: the process to FOLLOW for this work, stage by stage in the order '
-                    + 'above. It is not a document to summarise, quote back or file away.',
+                'When assigned execution, follow this workflow stage by stage. When assigned authoring '
+                    + 'or review only, edit or inspect it without starting work. Stage IDs above identify '
+                    + 'library stages; IDs inside Markdown tool links identify tool occurrences, not stages.',
             ].join('\n');
         },
     },
@@ -1210,7 +1235,9 @@ const TOOLS = [
             + 'is earlier than N or the same stage; a forward jump is refused and nothing is written. '
             + 'Takes no organisation or project: the workflow goes into the organisation this '
             + "conversation's project belongs to. It appears on /workflows at once. Never put an "
-            + 'absolute local path in any field.',
+            + 'absolute local path in any field. '
+            + 'branches are global conditions: when a condition holds, run runs_workflow_id in the same organisation and resume. '
+            + 'ending is end or next-in-backlog. Omitted settings are preserved on edit; branches: [] clears branches.',
         input: {
             name: z.string(),
             description: z.string().optional(),
@@ -1224,9 +1251,14 @@ const TOOLS = [
                 to_stage: z.number().int(),
                 condition: z.string(),
             })).optional(),
+            branches: z.array(z.object({
+                when: z.string().trim().min(1),
+                runs_workflow_id: z.string().uuid(),
+            })).optional().describe('the whole new branch list; omitted preserves current branches, [] clears them'),
+            ending: z.enum(['end', 'next-in-backlog']).optional(),
         },
         handler: async (caller, args) => {
-            const { name, description, stages, exits } = args;
+            const { name, description, stages, exits, branches, ending } = args;
             /* ═══ CHECKED HERE IN THE NUMBERING THE AGENT SENT. ═══
                `cliv2_build_workflow` enforces every one of these itself, and its
                messages count stages from 0, a numbering this tool never showed the
@@ -1269,6 +1301,8 @@ const TOOLS = [
                     body: stage.body,
                 })),
                 exits: wanted,
+                branches: branches?.map(branch => ({ when: branch.when, runsWorkflowId: branch.runs_workflow_id })),
+                ending,
                 fromAgent: harness(),
             });
             await receipt(caller, 'workflow', id, workflowName);
@@ -1364,8 +1398,12 @@ const TOOLS = [
             + 'must be earlier than from_stage or the same, and exits off one stage are tried in the order '
             + 'sent. name and description left out are left as they are; an empty description clears it. '
             + 'To change the wording of an '
-            + 'existing stage use reword_stage. Refused, with nothing written, while any work item is '
-            + 'running the workflow. Never put an absolute local path in any field.',
+            + 'existing stage use reword_stage first, then keep its stage number here. Read the current '
+            + 'workflow before editing. Never replace a retained stage with a new name/body entry just '
+            + 'to rename it, copy its wording, or bypass a protected-body refusal. Refused, with nothing written, while any work item is '
+            + 'running the workflow. Never put an absolute local path in any field. '
+            + 'branches are global conditions: when a condition holds, run runs_workflow_id in the same organisation and resume. '
+            + 'ending is end or next-in-backlog. Omitted settings are preserved on edit; branches: [] clears branches.',
         input: {
             workflow_id: z.string(),
             name: z.string().optional(),
@@ -1383,9 +1421,14 @@ const TOOLS = [
                 to_stage: z.number().int(),
                 condition: z.string(),
             })).optional().describe('the whole new list of conditional ways back; send [] for none'),
+            branches: z.array(z.object({
+                when: z.string().trim().min(1),
+                runs_workflow_id: z.string().uuid(),
+            })).optional().describe('the whole new branch list; omitted preserves current branches, [] clears them'),
+            ending: z.enum(['end', 'next-in-backlog']).optional(),
         },
         handler: async (caller, args) => {
-            const { workflow_id, name, description, stages, exits } = args;
+            const { workflow_id, name, description, stages, exits, branches, ending } = args;
             const workflowName = name?.trim();
             if (workflowName === '')
                 throw new Error('a workflow needs a name. Nothing was written.');
@@ -1436,10 +1479,8 @@ const TOOLS = [
                 description: description?.trim() ?? null,
                 stages: entries,
                 exits: zeroBasedExits(exits, entries.length),
-                /* THE BRANCHES GO BACK AS THEY CAME. The RPC rewrites them from what it
-                   is sent and nothing in v3 sets one, so sending anything else would
-                   delete what a person set on `/workflows`. */
-                branches: workflow.branches,
+                branches: branches?.map(branch => ({ when: branch.when, runsWorkflowId: branch.runs_workflow_id })) ?? workflow.branches,
+                ending,
                 fromAgent: harness(),
             });
             /* THE LABEL IS THE NAME THAT SURVIVED THE EDIT, which is the reply's own:
@@ -2010,7 +2051,8 @@ const TOOLS = [
         levels: [2],
         description: 'Offer the person the ending for this card: put the finished work onto the main branch, or '
             + 'leave it on its branch. Call this when the card\'s work is DONE and the codebase lands on '
-            + 'the main branch. You do not write the question or the answers and you never merge anything: '
+            + 'the main branch. First record verified completion with write_report(work_complete=true). '
+            + 'Use say for progress; this tool cannot announce work you intend to do. You do not write the question or the answers and you never merge anything: '
             + 'the product composes both, and it performs the merge itself if they choose to put the work '
             + 'back. Say in one sentence what was done, in their words. After this call, stop immediately: '
             + 'you are started again with what the product did with their answer.',
@@ -2030,8 +2072,13 @@ const TOOLS = [
                     + 'sentence saying what changed.');
             }
             const run = await only(client.from('panel3_runs')
-                .select('codebase_id, branch, base, card:panel3_cards!panel3_runs_card_id_fkey(project_id)')
+                .select('codebase_id, branch, base, completion_requested_token, card:panel3_cards!panel3_runs_card_id_fkey(project_id)')
                 .eq('id', runId), 'read', 'which branch this card\'s work is on');
+            if (run.completion_requested_token !== processToken) {
+                throw new Error('NOTHING WAS WRITTEN and nobody was asked. The assignment has not been declared complete in this turn. '
+                    + 'Finish and verify every requested codebase first, then call write_report with work_complete=true before offer_ending. '
+                    + 'Use say for a progress update, not offer_ending.');
+            }
             if (!run.codebase_id || !run.branch || !run.base || !run.card?.project_id) {
                 throw new Error('NOTHING WAS WRITTEN. This card has no codebase, branch and base recorded, so there is no '
                     + 'ending to offer. Say what you did and finish the card.');
@@ -2174,6 +2221,20 @@ const TOOLS = [
             return `Created work item ${item.name}, id ${item.id}.`;
         },
     },
+    {
+        name: 'edit_work_item_codebase',
+        levels: [1, 2],
+        description: 'Add or remove one SAVED work-item codebase target, preserving all other targets and attributes. Read get_work_item first for current targets and project codebase IDs. To select multiple codebases, add each; to replace a target, add its replacement before removing it. Duplicate additions are harmless. Re-read after edits or human changes. This edits the work item itself and provides an Open work item receipt; it does not attach to the conversation or execute files.',
+        input: { work_item_id: z.string().uuid(), codebase_id: z.string().uuid(), action: z.enum(['add', 'remove']) },
+        handler: async (caller, args) => {
+            const a = args;
+            const item = await only(caller.client.from('tasks')
+                .select('id, name, project_id').eq('id', a.work_item_id), 'read', 'the work item');
+            const targets = await editWorkItemCodebaseTarget(caller.client, item.id, item.project_id, a.codebase_id, a.action === 'add');
+            await receiptOnce(caller, 'work_item', item.id, item.name);
+            return JSON.stringify({ work_item_id: item.id, saved_codebase_targets: targets });
+        },
+    },
     // ── Do the work, and produce objects ─────────────────────────────────────
     //
     // ═══ EVERY LEVEL, AND THAT IS ux.md's FOURTH RULE. ═══ "Producing an object
@@ -2763,7 +2824,7 @@ const TOOLS = [
                 await whileRunning(client.rpc('panel3_request_completion', {
                     p_run_id: runId, p_process_token: processToken, p_summary: report,
                 }), runId, 'declare completion of');
-                return 'Completion recorded. Give your final answer and exit. Done waits until all processes have exited.';
+                return 'Completion recorded. If the finished work needs an ending choice, call offer_ending; otherwise give your final answer and exit. Done waits until all processes have exited.';
             }
             await whileRunning(processToken === undefined
                 ? client.from('panel3_runs').update({ report }).eq('id', runId)
@@ -2929,6 +2990,13 @@ const TOOLS = [
         },
     },
     // ── Dispatch and stop ────────────────────────────────────────────────────
+    {
+        name: 'list_codex_models',
+        levels: [1, 2],
+        description: 'Read the models and reasoning efforts currently offered by the installed Codex harness on this machine. Call before choosing a Codex child model yourself. This is discovery, not an allowlist for explicit user model IDs or aliases. If discovery fails, omit autonomous model/effort choices to use the installed defaults; never guess an identifier.',
+        input: {},
+        handler: async () => JSON.stringify(await listCodexModels()),
+    },
     {
         name: 'dispatch',
         /* ═══ ABSENT AT LEVEL 3, WHICH IS HOW "DEPTH STOPS AT THREE" IS ENFORCED.
@@ -2962,7 +3030,7 @@ const TOOLS = [
                 + 'context: what to find out or change, and in which part of the codebase.'),
             boundary: z.string().min(1).describe('What it must not touch, and where its work stops.'),
             work_item_id: z.string().optional().describe('The work item it is working, if there is one.'),
-            model: z.string().min(1).optional().describe('Exact model for this child. Copy the user\'s applicable value verbatim, including aliases; never expand or normalize it. Otherwise choose for the task. Omit for the harness or machine default, never parent inheritance.'),
+            model: z.string().min(1).refine(value => !/^(?:codex|claude(?: code)?)(?:\s|$)/i.test(value.trim()), 'Use only the model ID, without the Claude or Codex harness label. Omit model to use the installed default.').optional().describe('Exact model for this child. Copy the user\'s applicable value verbatim, including aliases; never expand or normalize it. Otherwise choose for the task: for Claude, prefer supported unversioned aliases such as sonnet or opus; do not invent version-suffixed aliases. For Codex, first call list_codex_models and choose from its result. If uncertain, omit for the harness or machine default, never parent inheritance.'),
             effort: z.string().min(1).optional().describe('Exact effort for this child. Honor the user\'s applicable wish; otherwise choose independently. Passed unchanged to the harness.'),
             work_name: z.string().optional().describe(`A few words, ${WORK_NAME_WORDS} at most, naming the WORK this conversation is doing, such `
                 + 'as "Fix the sign-out checklist bug". Pass it when the conversation has NO work item '
@@ -2992,6 +3060,9 @@ const TOOLS = [
                         + 'the work, do not describe it.');
                 }
             }
+            const attached = await loadAttachments(caller.client, caller.cardId);
+            const workItems = attached.filter(attachment => attachment.kind === 'work_item');
+            const scopedWorkItem = work_item_id ?? (workItems.length === 1 ? workItems[0].ref_id : undefined);
             let codebase = null;
             if (codebase_id) {
                 const projectId = await projectOfCard(caller);
@@ -3003,6 +3074,19 @@ const TOOLS = [
                 if (!codebase) {
                     throw new Error('That codebase is not registered on this project. Read the current project codebases and choose one of them.');
                 }
+                if (!scopedWorkItem && workItems.length > 1) {
+                    throw new Error('No agent was started. Identify the work item for this piece before choosing its codebase.');
+                }
+                if (scopedWorkItem) {
+                    await only(caller.client.from('tasks').select('id').eq('id', scopedWorkItem)
+                        .eq('project_id', projectId).is('archived_at', null).eq('is_idea', false), 'read', 'the live work item in this conversation\'s project');
+                    const targets = await listWorkItemCodebaseTargets(caller.client, scopedWorkItem);
+                    if (!targets.includes(codebase.gitRemoteUrl)) {
+                        throw new Error('No agent was started. This codebase is not a saved target of the work item. '
+                            + 'Read get_work_item for its current saved targets; if none are saved, ask the person to select one. '
+                            + 'Do not fall back to another project codebase or change targets to bypass this check.');
+                    }
+                }
             }
             /* ONE LEVEL DOWN, AND THE SAME ARITHMETIC THE DATABASE DOES. This decides
                the words in the brief; `panel3_dispatch` decides the level on the row,
@@ -3017,7 +3101,6 @@ const TOOLS = [
                three hops from level 1 still knows which item it is working, without
                asking. See `workBrief`'s own doc for why the two are different things
                carried the same way. */
-            const attached = await loadAttachments(caller.client, caller.cardId);
             /* ═══ THE CONVERSATION IS NAMED HERE OR IT IS NEVER NAMED. ═══ Sending
                somebody resolves the working copy, and resolving it cuts the branch
                from whatever the conversation is called at that moment and stamps it
@@ -3032,7 +3115,7 @@ const TOOLS = [
                     .select('id'), 'name', `card ${caller.cardId}`);
             }
             const attachments = attached.map(attachmentLine);
-            const { runId } = await caller.dispatch(caller.runId, workBrief(childLevel, responsibility, boundary, work_item_id, attachments, codebase === null ? undefined : {
+            const { runId } = await caller.dispatch(caller.runId, workBrief(childLevel, responsibility, boundary, scopedWorkItem, attachments, codebase === null ? undefined : {
                 id: codebase.id, name: codebase.name, identity: codebase.gitRemoteUrl,
             }), codebase, caller.processToken, { model, effort });
             /* ═══ WHERE ITS ANSWER GOES DEPENDS ON WHICH LEVEL THIS IS, AND THAT IS

package/dist/presence.js

@@ -9,6 +9,8 @@ import { buildPresenceHeartbeatPayload } from './presence-heartbeat.js';
 import { createListenerState, orchestratorTick, reapDeadWorkers, recoverStrandedWorkers, takeRunMessages, liveAgents, } from './orchestrator.js';
 /* 18c Slice 8 — the on-disk half of the crash recovery beside it. */
 import { sweepStrandedCodexHomes } from './codex-home.js';
+import { claimDaemonLock, releaseDaemonLock } from './daemon-lock.js';
+import { startPanel } from './panel3/run.js';
 let presence = null;
 /** In-flight guard: startPresence yields to the event loop (network setSession)
  *  before `presence` is assigned, so a plain `if (presence)` check lets two
@@ -246,21 +248,57 @@ async function cleanupSupersededRows(p) {
     }
 }
 async function pollCommands(p) {
+    if (p.pollingCommands)
+        return;
+    p.pollingCommands = true;
     try {
         const { data, error } = await p.client
             .from('cliv2_commands')
             .update({ status: 'ack', acked_at: new Date().toISOString() })
             .eq('machine_id', p.identity.id)
             .eq('status', 'pending')
+            .eq('command', 'ping')
             .select('id, command');
         if (error)
             throw error;
         for (const cmd of data ?? [])
             console.log(`Acked ${cmd.command} (${cmd.id})`);
+        const { data: restarts, error: restartError } = await p.client
+            .from('cliv2_commands')
+            .update({ status: 'processing' })
+            .eq('machine_id', p.identity.id)
+            .eq('status', 'pending')
+            .eq('command', 'restart_worker')
+            .select('id, created_at');
+        if (restartError)
+            throw restartError;
+        for (const command of restarts ?? []) {
+            let result = 'Worker restarted';
+            let status = 'ack';
+            try {
+                if (Date.now() - Date.parse(command.created_at) > 30_000) {
+                    throw new Error('This restart request expired. Try again while the machine is online.');
+                }
+                if (!p.panel)
+                    throw new Error('The worker has not started. Open Companion on this machine and reconnect.');
+                await p.panel.restart();
+            }
+            catch (error) {
+                status = 'failed';
+                result = error instanceof Error ? error.message : String(error);
+            }
+            const { error: saved } = await p.client.from('cliv2_commands')
+                .update({ status, result, acked_at: new Date().toISOString() }).eq('id', command.id);
+            if (saved)
+                throw saved;
+        }
     }
     catch (err) {
         console.warn(`command poll failed, will retry: ${err.message}`);
     }
+    finally {
+        p.pollingCommands = false;
+    }
 }
 /**
  * One turn of the orchestrator listener (feature 16, Slice 3). All the logic is
@@ -298,12 +336,17 @@ async function pollOrchestrator(p) {
  *  the companion guard for that; the terminal daemon lets it surface. No-op if
  *  already running. */
 export async function startPresence() {
+    if (stopping)
+        await stopping;
     if (presence) {
         return { machineName: presence.identity.name, agents: presence.agents };
     }
     if (starting)
         return starting;
     starting = (async () => {
+        const lock = claimDaemonLock();
+        if (lock.held)
+            throw new Error(`CTRL+SPC is already running on this computer (pid ${lock.pid}).`);
         const identity = getMachineIdentity();
         const agents = detectAgents();
         const client = await getClient();
@@ -337,6 +380,7 @@ export async function startPresence() {
             throw new Error('Signed-in user could not be resolved. Sign in again.');
         const p = {
             client,
+            panel: null,
             userId,
             identity,
             agents,
@@ -482,11 +526,19 @@ export async function startPresence() {
         catch (err) {
             console.warn(`Agent tools server did not start: ${err.message}`);
         }
+        // Both cs open and cs start answer cards through this one lifecycle.
+        // Read the owner's client on every use, including after refresh or logout.
+        p.panel = startPanel(() => p.client);
         return { machineName: identity.name, agents };
     })();
     try {
         return await starting;
     }
+    catch (error) {
+        await stopPresence();
+        releaseDaemonLock();
+        throw error;
+    }
     finally {
         starting = null;
     }
@@ -535,6 +587,7 @@ export async function stopPresence({ unregister = false } = {}) {
            call `stopPresence()` and kill the presence belonging to a DIFFERENT
            session, one that is signed in and healthy. */
         p.authSubscription.unsubscribe();
+        await p.panel?.stop();
         // On logout (unregister), scrub the ctrl-spc entry from each detected agent's
         // config so a logged-out machine leaves no dead server that would read "failed
         // to connect" on the next agent run. Fire-and-forget best-effort — never blocks
@@ -561,5 +614,6 @@ export async function stopPresence({ unregister = false } = {}) {
     }
     finally {
         stopping = null;
+        releaseDaemonLock();
     }
 }

package/dist/workflow-tool-mentions.js

@@ -123,6 +123,7 @@ export function authorToolMentions(body) {
 }
 export const WORKFLOW_AUTHORING_TEACHING = 'When the user asks you to create a workflow, build it in the library; do not merely describe it or execute it. ' +
     'Use ask_question for missing requirements that materially change the workflow, then continue after the answer. ' +
+    'If the user requests plain prose or no tool mentions, write plain Markdown only: do not add tool links, permissions, or an approval template. ' +
     'Encode every requested tool use and permission as a Markdown mention in the stage body. ' +
     'Use compact links: [@Create Artifact](ctrl-spc://tool/create_artifact?approval=not-required) to write a plan without asking; ' +
     '[@Ask Question](ctrl-spc://tool/ask_question?approval=not-required) to review its output; ' +

package/dist/workflows.js

@@ -144,6 +144,7 @@ export async function buildWorkflow(client, input) {
         prose.push([`stage ${i + 1} name`, stage.name], [`stage ${i + 1} description`, stage.description], [`stage ${i + 1} body`, stage.body]);
     });
     input.exits.forEach((exit, i) => prose.push([`exit ${i + 1} condition`, exit.condition]));
+    input.branches?.forEach((branch, i) => prose.push([`branch ${i + 1} condition`, branch.when]));
     for (const [field, value] of prose) {
         const token = absolutePathToken(value);
         if (token) {
@@ -158,8 +159,9 @@ export async function buildWorkflow(client, input) {
         p_description: input.description,
         p_stages: input.stages,
         p_exits: input.exits,
-        p_branches: [],
+        p_branches: (input.branches ?? []).map(branch => ({ when: branch.when, runs_workflow_id: branch.runsWorkflowId })),
         p_from_agent: input.fromAgent,
+        ...(input.ending === undefined ? {} : { p_ending: input.ending }),
     });
     if (error)
         throw new Error(`could not create workflow ${input.name}: ${error.message}`);
@@ -239,11 +241,8 @@ export async function rewordStage(client, input) {
  * behalf. Its refusals come back verbatim behind one sentence naming what was
  * being edited.
  *
- * ═══ BRANCHES ARE PASSED BACK AS THEY WERE READ. ═══ The RPC replaces them from
- * `p_branches`, and nothing in v3 sets one, so the caller hands back the list
- * `readWorkflow` read a moment before. A branch written between that read and
- * this call is lost, which is the posture the web's `replaceStructure` records
- * for itself.
+ * Branches are the complete replacement list. Callers preserve the current
+ * list when no branch change was requested, matching the web editor.
  *
  * ═══ NULL NAME OR DESCRIPTION MEANS UNCHANGED, ═══ which is the RPC's own
  * contract: an agent adding a stage does not restate a name it is not touching.
@@ -257,6 +256,7 @@ export async function editWorkflow(client, input) {
         prose.push([`stage ${i + 1} name`, stage.name], [`stage ${i + 1} description`, stage.description], [`stage ${i + 1} body`, stage.body]);
     });
     input.exits.forEach((exit, i) => prose.push([`exit ${i + 1} condition`, exit.condition]));
+    input.branches.forEach((branch, i) => prose.push([`branch ${i + 1} condition`, branch.when]));
     for (const [field, value] of prose) {
         const token = value === null ? null : absolutePathToken(value);
         if (token) {
@@ -273,6 +273,7 @@ export async function editWorkflow(client, input) {
         p_exits: input.exits,
         p_branches: input.branches.map((branch) => ({ when: branch.when, runs_workflow_id: branch.runsWorkflowId })),
         p_from_agent: input.fromAgent,
+        ...(input.ending === undefined ? {} : { p_ending: input.ending }),
     });
     if (error)
         throw new Error(`could not edit the workflow: ${error.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ctrl-spc/cs",
-  "version": "0.7.11",
+  "version": "0.7.13",
   "description": "CTRL+SPC — minimal, reliable per-machine agent presence. Sign-in, auto-start, agent detection, heartbeat presence, and ping acknowledgement.",
   "engines": {
     "node": ">=22"
@@ -18,7 +18,7 @@
   "scripts": {
     "build": "tsc",
     "start": "npm run build && node dist/index.js",
-    "test": "npm run build && node --test test/*.test.mjs"
+    "test": "npm run build && node --test --test-concurrency=1 test/*.test.mjs"
   },
   "license": "UNLICENSED",
   "dependencies": {