engineering-memory 1.11.16 → 1.11.18

package/dispatcher/sections.mjs

@@ -20,15 +20,17 @@ Never answer a question about a bound repository from the working tree alone. Wh
 
 After compaction, a new chat, interruption, or handoff, call \`session.resume\` before continuing.
 
-Before a new write/scaffold task, call \`task.branch\` directly: do not ask the user where, from which branch or under which name first, and do not call \`worktree.list\` for it. Its short native form asks only the starting branch and where to work. It generates the new branch name automatically; do not ask the user to name it unless they request a specific name. Nothing is created until the user answers. The pool reuses a safely available worktree slot before creating another; never pass or invent a worktree path. Reconcile protected legacy entries through the native recovery flow; clean files alone do not establish that the old agent and delivery have finished. Run all commands from its returned \`repoRoot\`. Renew \`task.heartbeat\` during actual work, use \`task.pause\` on handoff, and resume before writing again. Inactivity never permits force checkout or cleanup. Keep closed worktrees until authorized delivery completes. When \`session.entry\` says the user can manage them, unanswered shared branch preferences are asked together in one native form via \`project.set_git_preferences\`; other members choose only their own task base in \`task.branch\`. Answering "Not now" returns \`deferred\` with nothing allocated and a \`reconsider\` call; say so in one line, keep working on anything that does not depend on it, and make that \`reconsider\` call only when the user actually asks to start that task.
+Every new task starts with a short native mode selector through task.branch or session.bootstrap: Autonomous, Approve for me (recommended), or Ask for approval. Resume and compaction retain that task's selection. When the user wants to change mode, read decision.mode_status and open decision.mode at its current version. This selector always needs a real native user answer. Autonomous records reasoned agent decisions; Approve for me delegates routine decisions and asks critical ones; Ask for approval asks every required decision. Follow the skill's questionnaires reference and use questionnaire.decide for delegated_decision_required, comparing alternatives and reviewing the user's interests. Never blindly choose the recommendation or relay agent decisions as native answers. Releases, irreversible changes, access, spending, scope expansion and rule exceptions are critical. A mode never overrides host permissions or the normal verification gates.
+
+Before a new write/scaffold task, call \`task.branch\` directly: do not ask the user where, from which branch or under which name first, and do not call \`worktree.list\` for it. After the task mode is selected, its short start decision asks only the starting branch and where to work. It generates the new branch name automatically; do not ask the user to name it unless they request a specific name. Nothing is created until the mode-governed start decision is recorded. The pool reuses a safely available worktree slot before creating another; never pass or invent a worktree path. Reconcile protected legacy entries through the native recovery flow; clean files alone do not establish that the old agent and delivery have finished. Run all commands from its returned \`repoRoot\`. Renew \`task.heartbeat\` during actual work, use \`task.pause\` on handoff, and resume before writing again. Inactivity never permits force checkout or cleanup. Keep closed worktrees until authorized delivery completes. When \`session.entry\` says the user can manage them, unanswered shared branch preferences are asked together in one native form via \`project.set_git_preferences\`; other members choose only their own task base in \`task.branch\`. Answering "Not now" returns \`deferred\` with nothing allocated and a \`reconsider\` call; say so in one line, keep working on anything that does not depend on it, and make that \`reconsider\` call only when the user actually asks to start that task.
 
 Do not edit until the skill lifecycle has completed discovery, its checkpoint, and \`context.prepare_change\`. Do not claim completion until \`task.verify\` succeeds.
 
-Do not block independent task work on \`memory.propose_revision\` drafting, submission or approval. Follow the skill's memory-updates reference: use background agents or concurrent tools when the host permits them, and continue useful work instead of immediately waiting. Without concurrency, checkpoint the pending draft and defer submission until needed. Collect the result only at the operation that depends on it; native approval and required task verification still apply.
+Do not block independent task work on \`memory.propose_revision\` drafting, submission or approval. Follow the skill's memory-updates reference: use background agents or concurrent tools when the host permits them, and continue useful work instead of immediately waiting. Without concurrency, checkpoint the pending draft and defer submission until needed. Collect the result only at the operation that depends on it; the current mode's decision receipt and required task verification still apply.
 
 A check whose answer decides the next action — delivery preconditions such as the commit hook, the remote and the branch; whether verification or close can pass; what a waiver allows — is run by the agent that takes that action, in its own turn. Hand work to another agent only when you have other real work to do while it runs, and never take the action a delegated check gates before its answer is back. Work another agent checked is neither the user's approval nor task verification. Size delegation to the task — a one- or two-file change needs no multi-agent workflow — and once work is delegated, wait for its real completion signal, never a sleep loop polling its output.
 
-Choose question detail to suit the decision: task start is short, while complex decisions retain context and examples. Put a deliberate recommended choice first and preserve the host's free-input path without requiring an option or adding a duplicate Other choice; feedback is not consent. Use the host's native questionnaire for every question to the user, including implementation choices, names, clarification, branch/worktree decisions and delivery. For a required decision, use \`questionnaire.ask\` to open a durable native MCP form and \`questionnaire.resume\` to return to the same unanswered question. Read the skill's questionnaires reference first. Write every question in the user's language, say in \`context\` why it is asked, give in \`example\` one concrete thing the decision changes, and give every option a \`description\` of what happens next. Show a record by its title, never by an id or a hash. When the user says they did not understand, that is not an answer: explain in chat and show the same question again. Never use request_user_input_async for a required decision: it does not wait for an answer. When the durable form is unavailable, use a blocking native control only where the host permits it: request_user_input in Codex or AskUserQuestion in Claude. Never replace the questionnaire with a chat instruction such as 'type this', 'reply yes', or 'write X if you want Y'. Do not open a survey web page. If the required native control is unavailable or prohibited for that kind of question, follow the host's tool restrictions, explain the limitation, and continue only work already authorized; do not fabricate a survey or silently choose an answer. A timeout, dismissed form, empty response or ended turn is not an answer. Keep the decision pending and resume it; do not start dependent work or report it as resolved. Existing answers remain valid through retries and handoffs.
+Choose question detail to suit the decision: task start is short, while complex decisions retain context and examples. Put a deliberate recommended choice first and preserve the host's free-input path without requiring an option or adding a duplicate Other choice; feedback is not consent. When the task mode requires a user answer, use the host's native questionnaire for every question to the user, including implementation choices, names, clarification, branch/worktree decisions and delivery. For a required decision, use \`questionnaire.ask\` to open a durable native MCP form and \`questionnaire.resume\` to return to the same unanswered question. Read the skill's questionnaires reference first. Write every question in the user's language, say in \`context\` why it is asked, give in \`example\` one concrete thing the decision changes, and give every option a \`description\` of what happens next. Show a record by its title, never by an id or a hash. When the user says they did not understand, that is not an answer: explain in chat and show the same question again. Never use request_user_input_async for a required decision: it does not wait for an answer. When the durable form is unavailable, use a blocking native control only where the host permits it: request_user_input in Codex or AskUserQuestion in Claude. Never replace the questionnaire with a chat instruction such as 'type this', 'reply yes', or 'write X if you want Y'. Do not open a survey web page. If the required native control is unavailable or prohibited for that kind of question, follow the host's tool restrictions, explain the limitation, and continue only work already authorized; do not fabricate a survey or silently choose an answer. A timeout, dismissed form, empty response or ended turn is not an answer. Keep the decision pending and resume it; do not start dependent work or report it as resolved. Existing answers remain valid through retries and handoffs.
 
 When a durable MCP form cannot be displayed, read its \`hostFallback\` or call \`questionnaire.resume\` with \`presentation: host_native\` to get the original question without reopening the MCP form. Display the same question, all choices and notices through a blocking native control only if the host permits that control for this decision. After an actual native answer, call \`questionnaire.answer_from_host\` with the unchanged questionnaireId, requestKey and contentHash, the hostTool name and the returned choice/text. This is an agent-reported relay, not MCP transport attestation. Then retry the owning operation; its authority, content and version checks still apply. Never relay prose consent, a default, an asynchronous response or a cancelled/declined/missing answer. Decline alone is not proof that the host cannot display forms. Keep the decision pending if no permitted native control can represent it.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.11.16",
+  "version": "1.11.18",
   "description": "Installs the Engineering Memory skill and its local MCP bridge. Sign in after installing; your organization and project are resolved from your account.",
   "license": "UNLICENSED",
   "type": "module",

package/runtime/build.json

@@ -1,3 +1,3 @@
 {
-  "gitHead": "9623849ae66a8cc72716533cb131790a4c517ac7"
+  "gitHead": "48fd7723e54001de0eb1d65510ef337935b992bc"
 }

package/runtime/dist/src/config.js

@@ -77,6 +77,7 @@ export const endpoints = {
     projectRestore: (projectId) => `/projects/${projectId}/restore`,
     projectMemberAdd: (projectId) => `/projects/${projectId}/members`,
     projectMemberList: (projectId) => `/projects/${projectId}/members`,
+    workItemStatuses: (projectId) => `/projects/${projectId}/work-items/statuses`,
     workItemList: (projectId) => `/projects/${projectId}/work-items`,
     workItemGet: (projectId, workItemId) => `/projects/${projectId}/work-items/${workItemId}`,
     projectLink: '/projects/link',

package/runtime/dist/src/mcp/decision-tools.js

@@ -0,0 +1,119 @@
+import * as z from 'zod/v4';
+import { decisionTaskId } from '../runtime/decision-mode-store.js';
+import { delegatedReasonSchema, hostAnswerSchema, languageTag, } from '../runtime/questionnaire-store.js';
+import { askQuestionnaire, answerChoice } from './questionnaire-tools.js';
+const modeInput = z.strictObject({
+    repoRoot: z.string().min(1).optional(),
+    externalTaskId: decisionTaskId,
+    expectedVersion: z.number().int().min(0),
+    decisionAttempt: z.number().int().min(1).max(10000).optional(),
+    language: languageTag.optional(),
+    presentation: z.enum(['host_native']).optional(),
+});
+function result(data) {
+    return { content: [{ type: 'text', text: JSON.stringify({ ok: true, data }) }] };
+}
+function failure(error) {
+    return {
+        isError: true,
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    ok: false,
+                    error: {
+                        kind: 'decision_mode_error',
+                        message: error instanceof Error ? error.message : 'Decision mode operation failed.',
+                        retryable: false,
+                    },
+                }),
+            },
+        ],
+    };
+}
+async function chooseMode(server, service, input, context) {
+    const definition = await service.decisionModeQuestion(input);
+    const form = await askQuestionnaire(server, service, {
+        ...definition,
+        repoRoot: input.repoRoot,
+        presentation: input.presentation,
+    }, context, [], {
+        tool: 'decision.mode',
+        externalTaskId: input.externalTaskId,
+        ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
+        retryArguments: { expectedVersion: input.expectedVersion, language: definition.language },
+    });
+    if (!answerChoice(form))
+        return { form };
+    const state = await service.decisionModeSelect({
+        ...input,
+        questionnaireId: definition.questionnaireId,
+    });
+    return { state };
+}
+export async function ensureDecisionMode(server, service, input, context) {
+    try {
+        if ((await service.decisionModeStatus(input)).configured)
+            return null;
+        const chosen = await chooseMode(server, service, { ...input, expectedVersion: 0 }, context);
+        return chosen.form ?? null;
+    }
+    catch (error) {
+        return failure(error);
+    }
+}
+export function registerDecisionTools(server, service) {
+    server.registerTool('decision.mode_status', {
+        description: 'Read the decision mode and version of this exact task. A missing selection defaults to ask and requires the native task-start mode form. Resuming a task keeps its selection; other tasks are independent.',
+        inputSchema: modeInput.pick({ repoRoot: true, externalTaskId: true }),
+    }, async (input) => {
+        try {
+            return result(await service.decisionModeStatus(input));
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+    server.registerTool('decision.mode', {
+        description: 'Open the three-choice native task mode form at task start or whenever the user wants to change mode. Read decision.mode_status and pass its version as expectedVersion. Always let the user select this mode, including while autonomous. Feedback, dismissal and defaults never select a mode. Retry identical arguments to apply an answered question.',
+        inputSchema: modeInput,
+    }, async (input, context) => {
+        try {
+            const chosen = await chooseMode(server, service, input, context);
+            return chosen.form ?? result(chosen.state);
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+    server.registerTool('questionnaire.decide', {
+        description: 'Record a reasoned agent decision only when this task mode delegates it. Read the exact pending question and mode version. Deliberate from the user goals, compare alternatives and independently review their interests; never blindly choose the recommended option. This records delegated_agent provenance, never a user answer. Critical decisions in approve-for-me and all mode switches require native answers. Retry the owning operation afterwards; authority, scope, validation and host permissions still apply.',
+        inputSchema: z.strictObject({
+            questionnaireId: hostAnswerSchema.shape.questionnaireId,
+            requestKey: hostAnswerSchema.shape.requestKey,
+            contentHash: hostAnswerSchema.shape.contentHash,
+            answer: hostAnswerSchema.shape.answer,
+            answers: hostAnswerSchema.shape.answers,
+            repoRoot: z.string().min(1).optional(),
+            modeVersion: z.number().int().positive(),
+            ...delegatedReasonSchema.shape,
+        }),
+    }, async (input) => {
+        try {
+            const resolved = await service.questionnaireDecide(input);
+            return result({
+                questionnaireId: resolved.record.questionnaireId,
+                status: resolved.record.status,
+                answerAvailable: resolved.record.answerAvailable,
+                answer: resolved.record.answer,
+                answers: resolved.record.answers,
+                answerSource: resolved.record.answerSource,
+                retry: resolved.retry,
+            });
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+}
+//# sourceMappingURL=decision-tools.js.map

package/runtime/dist/src/mcp/questionnaire-tools.js

@@ -76,12 +76,10 @@ async function present(server, service, record, repoRoot, context, preparation,
     if (record.status === 'answered') {
         if (inputResponse(context.mcpReq.inputResponses, record.requestKey).kind !== 'missing')
             consumedResponses(context).add(record.requestKey);
-        return answered(record, record.questions ? record.answers : record.answer, true);
+        return answered(record, record.questions ? record.answers : record.answer, true, service.questionnaireRetry(record, repoRoot ?? process.cwd()));
     }
     if (context.mcpReq.signal.aborted)
         return pending(record, 'interrupted');
-    if (presentation === 'host_native')
-        return pending(record, 'host_native_requested');
     const responses = context.mcpReq.inputResponses;
     const response = inputResponse(responses, record.requestKey);
     if (response.kind === 'elicit' && response.action === 'accept') {
@@ -125,7 +123,7 @@ async function present(server, service, record, repoRoot, context, preparation,
             scope: record.scope,
             answer: answer,
         });
-        return answered(resolved.record, resolved.answer, resolved.replayed);
+        return answered(resolved.record, resolved.answer, resolved.replayed, service.questionnaireRetry(resolved.record, repoRoot ?? process.cwd()));
     }
     if (response.kind === 'elicit')
         return pending(record, response.action);
@@ -133,6 +131,18 @@ async function present(server, service, record, repoRoot, context, preparation,
         context.mcpReq.droppedInputResponseKeys?.length ||
         Object.keys(responses ?? {}).some((key) => !consumedResponses(context).has(key)))
         return pending(record, 'missing_or_stale_response');
+    const policy = await service.questionnaireDecisionPolicy(record);
+    if (policy.delegated && presentation !== 'host_native') {
+        const waiting = pending(record, 'delegated_decision_required');
+        const data = JSON.parse(waiting.content[0].text).data;
+        return result({
+            ...data,
+            decisionPolicy: policy,
+            nextAction: 'Evaluate the choices against the user goals, compare alternatives, and review the choice from their perspective. Call questionnaire.decide with this exact identity, mode version and your reasoning. This is an agent decision, not native user consent. Then retry the owning operation. If approve-for-me and the chosen action is critical, resume the form with presentation host_native.',
+        });
+    }
+    if (presentation === 'host_native')
+        return pending(record, 'host_native_requested');
     const envelope = context.mcpReq.envelope;
     const capabilities = envelope?.[CLIENT_CAPABILITIES_META_KEY] ?? server.server.getClientCapabilities();
     const elicitation = capabilities?.elicitation;

package/runtime/dist/src/mcp/tool-annotations.js

@@ -26,6 +26,9 @@ export const toolAnnotations = {
     'task.pause': write,
     'worktree.release': destructive,
     'audit.list': read,
+    'decision.mode': repeatableWrite,
+    'decision.mode_status': read,
+    'questionnaire.decide': repeatableWrite,
     'questionnaire.ask': repeatableWrite,
     'questionnaire.resume': repeatableWrite, // records an accepted answer
     'questionnaire.answer_from_host': repeatableWrite,
@@ -100,6 +103,7 @@ export const toolAnnotations = {
     'work_item.confirm_plan': write,
     'project.update': write,
     'work_item.list': read,
+    'work_item.statuses': read,
     'work_item.get': read,
     'project.clone': outward,
     'project.link': write,

package/runtime/dist/src/mcp/tool-definitions.js

@@ -1,3 +1,4 @@
+import { ensureDecisionMode, registerDecisionTools } from './decision-tools.js';
 import * as z from 'zod/v4';
 import { validationIds } from '../runtime/bridge-service.js';
 import { stableStringify } from '../utilities/hash.js';
@@ -47,6 +48,9 @@ const checkpointBase = {
     idempotencyKey: z.string().uuid().optional(),
 };
 export const engineeringMemoryToolNames = [
+    'decision.mode',
+    'decision.mode_status',
+    'questionnaire.decide',
     'project.git_preferences',
     'project.set_git_preferences',
     'worktree.policy',
@@ -130,6 +134,7 @@ export const engineeringMemoryToolNames = [
     'work_item.plan',
     'work_item.confirm_plan',
     'project.update',
+    'work_item.statuses',
     'work_item.list',
     'work_item.get',
     'project.clone',
@@ -190,6 +195,7 @@ const waiverCopy = {
     },
 };
 export function registerQuestionnaireTools(server, service) {
+    registerDecisionTools(server, service);
     server.registerTool('questionnaire.answer_from_host', {
         description: 'Relay an actual answer from a host-permitted blocking native AskUserQuestion or request_user_input control to the exact durable question. First read hostFallback from the pending operation or questionnaire.resume with presentation host_native, display its unchanged question/options/notices and await the real native result. Never infer answers, use chat consent, asynchronous controls, defaults or a declined/dismissed form. The hostTool field is agent-reported provenance, not transport-verified attestation. Bind requestKey and contentHash exactly; changed scope, withdrawn questions, invalid or conflicting answers are refused. This only saves the answer; retry the owning operation for current authority and version checks.',
         inputSchema: hostAnswerSchema.extend({
@@ -228,7 +234,7 @@ export function registerQuestionnaireTools(server, service) {
         }
     });
     server.registerTool('questionnaire.ask', {
-        description: 'Persist a required decision before displaying a native questionnaire. Write the message, context, example, labels and option descriptions in the language the user writes in, and set language to its BCP-47 tag (tr, en, pt-BR); it is remembered, and the call is refused while no language is known. Say why the decision is asked in context, give one concrete example of what it changes in example, and give every option a description of what happens next. Show a record by its title, never by an id or a hash. Use a questionnaireId unique to this decision occurrence or task, and reuse it only for identical retries. A later decision or changed wording/options requires a new id. Only a schema-validated native acceptance answers it. Dismissal, timeout and missing replies remain pending without expiry. Never supply answers in questionnaire.ask arguments; use questionnaire.answer_from_host only after an actual permitted blocking native answer. Do not put personal information or secrets in the question or options. Free text is returned once and never stored; use explicit options for replayable decisions. After the first decline in this session, pass presentation host_native to skip the doomed elicitation round trip.',
+        description: 'Persist a required decision before displaying a native questionnaire. Write the message, context, example, labels and option descriptions in the language the user writes in, and set language to its BCP-47 tag (tr, en, pt-BR); it is remembered, and the call is refused while no language is known. Say why the decision is asked in context, give one concrete example of what it changes in example, and give every option a description of what happens next. Show a record by its title, never by an id or a hash. Use a questionnaireId unique to this decision occurrence or task, and reuse it only for identical retries. A later decision or changed wording/options requires a new id. An answer is either a schema-validated native acceptance or a reasoned questionnaire.decide receipt permitted by the selected task mode. Dismissal, timeout and missing replies remain pending without expiry. Never supply answers in questionnaire.ask arguments; use questionnaire.answer_from_host only after an actual permitted blocking native answer. Do not put personal information or secrets in the question or options. Free text is returned once and never stored; use explicit options for replayable decisions. After the first decline in this session, pass presentation host_native to skip the doomed elicitation round trip.',
         inputSchema: questionnaireDefinitionSchema.extend({
             repoRoot: optionalRepoRoot,
             preparation: z.boolean().optional(),
@@ -329,9 +335,11 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input) => toolResult(await service.sessionAnswerShadowNotice(input)));
     server.registerTool('session.bootstrap', {
-        description: 'Authenticate, resolve the repository project, open or resume a write or read-only task, and load mandatory engineering context before planning. objective is one line of at most 240 characters. contextPack holds only what fit the response budget; deferredResources lists what did not, each entry carrying its revisionId so it can be read directly with memory.read_revisions rather than looked up again through memory.catalog.',
+        description: 'First select the decision mode of a new task through a short native form, then authenticate, resolve the repository project, open or resume a write or read-only task, and load mandatory engineering context before planning. objective is one line of at most 240 characters. contextPack holds only what fit the response budget; deferredResources lists what did not, each entry carrying its revisionId so it can be read directly with memory.read_revisions rather than looked up again through memory.catalog.',
         inputSchema: z.object({
             repoRoot: optionalRepoRoot,
+            language: languageTag.optional(),
+            presentation: z.enum(['host_native']).optional(),
             projectId: z.string().optional(),
             externalTaskId: z
                 .string()
@@ -367,7 +375,13 @@ export function registerEngineeringMemoryTools(server, service) {
                 .optional(),
             knownRevisions: z.record(z.string(), z.number().int().min(0)).optional(),
         }),
-    }, async (input) => toolResult(await service.sessionBootstrap(input)));
+    }, async (input, context) => {
+        const mode = await ensureDecisionMode(server, service, input, context);
+        if (mode)
+            return mode;
+        const { language: _language, presentation: _presentation, ...bootstrap } = input;
+        return toolResult(await service.sessionBootstrap(bootstrap));
+    });
     server.registerTool('session.resume', {
         description: 'Merge backend events, local journal, offline outbox, pinned context and current Git state after a new chat or context compaction.',
         inputSchema: z.object({
@@ -932,7 +946,7 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input) => toolResult(await service.workItemCreate(input)));
     server.registerTool('work_item.update', {
-        description: "Edit or assign a work item at its current version. Assignees must already be active project members; this does not grant project access. Status is a slug from the project's own status catalogue; a backend that still keeps the six legacy values (backlog, ready, in_progress, in_review, done, cancelled) refuses anything else and names what it accepts.",
+        description: 'Edit or assign a work item at its current version. Assignees must already be active project members; this does not grant project access. Read work_item.statuses before changing status. Send the actual project catalogue slug and follow its user-defined meaning, entryRule and flags; never infer workflow from a status name.',
         inputSchema: z.object({
             ...workItemLocator,
             data: z.object({
@@ -1015,11 +1029,22 @@ export function registerEngineeringMemoryTools(server, service) {
             }),
         }),
     }, async (input) => toolResult(await service.projectUpdate(input)));
+    server.registerTool('work_item.statuses', {
+        description: 'Read the project status catalogue before choosing a work item status. Follow the user-defined meaning, entryRule and flags; never infer workflow from status names. Page with offset and limit (defaults 0 and 50, maximum 100). Archived statuses are excluded unless includeArchived is true.',
+        inputSchema: z.object({
+            projectId: z.string().uuid(),
+            offset: z.number().int().min(0).optional(),
+            limit: z.number().int().min(1).max(100).optional(),
+            includeArchived: z.boolean().optional(),
+        }),
+    }, async (input) => toolResult(await service.workItemStatuses(input)));
     server.registerTool('work_item.list', {
-        description: "List selectable work items for a project before opening an engineering run in this chat. The status filter is a slug from the project's own status catalogue; a backend that still keeps the six legacy values (backlog, ready, in_progress, in_review, done, cancelled) refuses anything else and names what it accepts.",
+        description: 'List selectable work items for a project before opening an engineering run in this chat. Read work_item.statuses for the actual project catalogue slugs and user-defined meanings; never infer workflow from status names. The status filter matches an actual slug, including a retained archived status; an unknown slug returns an empty page.',
         inputSchema: z.object({
             projectId: z.string().uuid(),
             status: z.string().trim().min(1).max(64).optional(),
+            offset: z.number().int().min(0).optional(),
+            limit: z.number().int().min(1).max(100).optional(),
             priority: z.enum(['lowest', 'low', 'medium', 'high', 'highest']).optional(),
             assigneeUserId: z.string().uuid().optional(),
             includeArchived: z.boolean().optional(),

package/runtime/dist/src/mcp/worktree-tools.js

@@ -1,3 +1,4 @@
+import { ensureDecisionMode } from './decision-tools.js';
 import { basename } from 'node:path';
 import * as z from 'zod/v4';
 import { cancelledDeliveryQuestionId, forgetUnreadableQuestionId, retireQuestionId, } from '../runtime/bridge-service.js';
@@ -358,7 +359,7 @@ export function registerWorktreeTools(server, service) {
         inputSchema: z.strictObject(policy),
     }, async (input) => output(await service.worktreePolicy(json(input))));
     server.registerTool('task.branch', {
-        description: 'Start a write task with ONE durable native form: two short questions for the starting branch (unless base is given) and the folder. A unique branch name is generated automatically unless name is supplied. Folder options: a separate managed worktree, this folder as a new branch when it is clean (moving out an unfinished task that holds it, named in the option), this folder on its current branch, or not now. Nothing is created until the user answers; the next call with the same arguments allocates. A remote base is fetched and its exact commit pinned. Retry/resume preserves the allocation. Not now returns status deferred with the exact reconsider call; retries keep the same decisionAttempt. Use the returned repoRoot for ALL commands. A read-only task allocates only when transitioning to write.',
+        description: 'Start a write task by selecting its decision mode in one short native form, then resolve two short questions for the starting branch (unless base is given) and the folder. A unique branch name is generated automatically unless name is supplied. Folder options: a separate managed worktree, this folder as a new branch when it is clean (moving out an unfinished task that holds it, named in the option), this folder on its current branch, or not now. Nothing is created until a valid native or mode-delegated start answer is recorded; the next call with the same arguments allocates. A remote base is fetched and its exact commit pinned. Retry/resume preserves the allocation. Not now returns status deferred with the exact reconsider call; retries keep the same decisionAttempt. Use the returned repoRoot for ALL commands. A read-only task allocates only when transitioning to write.',
         inputSchema: z.strictObject({
             repoRoot: repo,
             externalTaskId: z.string().min(2).max(160),
@@ -377,6 +378,9 @@ export function registerWorktreeTools(server, service) {
         const flight = preflight.data;
         if (flight.existingAllocation)
             return output(await service.taskBranch(input));
+        const mode = await ensureDecisionMode(server, service, input, context);
+        if (mode)
+            return mode;
         const role = input.base?.kind;
         if ((role === 'development' || role === 'production' || role === 'test') &&
             !configuredBase(flight.preferences, role))

package/runtime/dist/src/runtime/api-client.js

@@ -20,6 +20,7 @@ export const backendRecoveryOperationNames = [
     'organization.list',
     'project.member_add',
     'work_item.list',
+    'work_item.statuses',
     'work_item.get',
     'session.bootstrap',
     'session.resume',
@@ -90,6 +91,9 @@ export class ApiClient {
         this.options = options;
         this.fetchImplementation = options.fetchImplementation ?? fetch;
     }
+    get namespace() {
+        return sha256(this.options.baseUrl.replace(/\/+$/, ''));
+    }
     async request(path, request = {}) {
         const method = request.method ?? 'GET';
         const cacheKey = request.cacheKey ?? this.cacheKey(method, path, request.body);

package/runtime/dist/src/runtime/bridge-service.js

@@ -1,3 +1,5 @@
+import { decisionModeSchema } from './decision-mode-store.js';
+import { delegatedReasonSchema } from './questionnaire-store.js';
 import { unreadableWorktree, } from './worktree-pool.js';
 import { validWorktreePolicy } from './worktree-policy.js';
 import { resolveTaskBase } from './branch-preferences.js';
@@ -57,6 +59,202 @@ export class BridgeService {
             await this.dependencies.languages.remember(principalHash, told);
         return told ?? (await this.dependencies.languages.read(principalHash));
     }
+    async decisionModeStatus(input) {
+        const scope = await this.questionnaireScope(input.repoRoot);
+        return this.dependencies.questionnaires.decisions.read(scope, this.dependencies.client.namespace, input.externalTaskId);
+    }
+    async decisionModeQuestion(input) {
+        const scope = await this.questionnaireScope(input.repoRoot);
+        if (!scope.projectId || !(await this.dependencies.credentials.get('access-token')))
+            throw refuse('Select a signed-in project before choosing a task decision mode.', 'session.entry');
+        const namespace = this.dependencies.client.namespace;
+        const id = 'decision-mode-' +
+            sha256(stableStringify({
+                scope,
+                namespace,
+                task: input.externalTaskId,
+                version: input.expectedVersion,
+                ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
+            }));
+        const current = await this.decisionModeStatus(input);
+        if (current.version !== input.expectedVersion &&
+            !(current.version === input.expectedVersion + 1 && current.questionnaireId === id))
+            throw refuse('The mode changed. Read decision.mode_status before opening another mode question.', 'decision.mode_status');
+        const language = await this.language(input.language);
+        const existing = await this.dependencies.questionnaires.get(scope, id);
+        if (existing) {
+            if (existing.owner?.tool !== 'decision.mode' ||
+                existing.owner.externalTaskId !== input.externalTaskId)
+                throw refuse('This mode question has a different owner. Start a new decisionAttempt.', 'decision.mode');
+            if (existing.status === 'withdrawn')
+                throw refuse('The mode question was withdrawn. When the user resumes this choice, increment decisionAttempt without changing expectedVersion.', 'decision.mode');
+            return {
+                questionnaireId: id,
+                message: existing.message,
+                context: existing.context,
+                example: existing.example,
+                language: existing.language,
+                options: existing.options,
+                binding: existing.binding,
+            };
+        }
+        const tr = language?.startsWith('tr');
+        const definition = {
+            questionnaireId: id,
+            message: tr
+                ? input.expectedVersion
+                    ? 'Hangi moda geçelim?'
+                    : 'Bu taskta nasıl ilerleyelim?'
+                : input.expectedVersion
+                    ? 'Which mode should we switch to?'
+                    : 'How should we work on this task?',
+            context: tr
+                ? 'Seçim bu task için geçerli; istediğinde değiştirebilirsin.'
+                : 'This choice applies to this task; you can change it anytime.',
+            example: tr
+                ? 'Örneğin canlıya alma kararını ajana bırakabilir veya kendin onaylayabilirsin.'
+                : 'For example, you can delegate a release decision or approve it yourself.',
+            language: tr ? 'tr' : 'en',
+            options: tr
+                ? [
+                    {
+                        id: 'approve_for_me',
+                        label: 'Benim için onayla',
+                        description: 'Sıradan kararları ben veririm; çok kritik olanları sana sorarım.',
+                    },
+                    {
+                        id: 'autonomous',
+                        label: 'Otonom',
+                        description: 'Seçenekleri senin hedeflerine göre değerlendirip kararları gerekçesiyle veririm.',
+                    },
+                    {
+                        id: 'ask',
+                        label: 'Onay iste',
+                        description: 'Karar gereken her durumda sana sorarım.',
+                    },
+                ]
+                : [
+                    {
+                        id: 'approve_for_me',
+                        label: 'Approve for me',
+                        description: 'I decide routine matters and ask you about critical ones.',
+                    },
+                    {
+                        id: 'autonomous',
+                        label: 'Autonomous',
+                        description: 'I weigh the choices against your goals and record my reasoning.',
+                    },
+                    {
+                        id: 'ask',
+                        label: 'Ask for approval',
+                        description: 'I ask you whenever a decision is needed.',
+                    },
+                ],
+            binding: {
+                namespace,
+                externalTaskId: input.externalTaskId,
+                expectedVersion: input.expectedVersion,
+            },
+        };
+        return definition;
+    }
+    async decisionModeSelect(input) {
+        const record = await this.questionnaireResume(input);
+        const namespace = this.dependencies.client.namespace;
+        if (record.owner?.tool !== 'decision.mode' ||
+            record.owner.externalTaskId !== input.externalTaskId ||
+            record.binding?.namespace !== namespace ||
+            record.binding?.externalTaskId !== input.externalTaskId ||
+            record.binding?.expectedVersion !== input.expectedVersion ||
+            record.status !== 'answered' ||
+            !record.answerAvailable ||
+            record.answerSource?.kind === 'delegated_agent')
+            throw refuse('A mode can only be selected through its native task mode question.', 'decision.mode');
+        const mode = decisionModeSchema.parse(record.answer?.choice);
+        return this.dependencies.questionnaires.decisions.select(record.scope, namespace, input.externalTaskId, input.expectedVersion, mode, record.questionnaireId);
+    }
+    async questionnaireDecisionPolicy(record, answer) {
+        const externalTaskId = record.owner?.externalTaskId;
+        const state = externalTaskId
+            ? await this.dependencies.questionnaires.decisions.read(record.scope, this.dependencies.client.namespace, externalTaskId)
+            : null;
+        let impact = record.owner?.tool === 'questionnaire.ask' ? (record.impact ?? 'critical') : 'critical';
+        if (record.owner?.tool === 'task.branch' && record.binding) {
+            if (!answer)
+                impact = 'routine';
+            else {
+                const selected = taskStartChoice({
+                    ...record,
+                    status: 'answered',
+                    answerAvailable: true,
+                    ...(record.questions
+                        ? { answers: answer }
+                        : { answer: answer }),
+                });
+                if (selected?.status === 'deferred' ||
+                    (selected?.status === 'start' && !selected.inPlace && !selected.keepCurrent))
+                    impact = 'routine';
+            }
+        }
+        if (record.questionnaireId.startsWith('rule-deviation-') ||
+            record.questionnaireId.startsWith('validation-waiver-'))
+            impact = 'critical';
+        const userOnly = record.owner?.tool === 'decision.mode' || !record.scope.projectId || !externalTaskId;
+        const delegated = !userOnly &&
+            !!state?.configured &&
+            (state.mode === 'autonomous' || (state.mode === 'approve_for_me' && impact === 'routine'));
+        return { delegated, impact, state, userOnly };
+    }
+    async assertDecisionCurrent(record) {
+        const source = record.answerSource;
+        if (source?.kind !== 'delegated_agent')
+            return;
+        const policy = await this.questionnaireDecisionPolicy(record, record.questions ? record.answers : record.answer);
+        if (!policy.delegated ||
+            policy.state?.version !== source.modeVersion ||
+            policy.state.mode !== source.mode ||
+            record.owner?.externalTaskId !== source.externalTaskId ||
+            source.namespace !== this.dependencies.client.namespace)
+            throw refuse('The mode changed after this delegated answer. Re-evaluate using a new questionnaireId, or increment the owning operation decisionAttempt. Do not execute this answer.', 'questionnaire.resume');
+    }
+    async questionnaireDecide(input) {
+        const scope = await this.questionnaireScope(input.repoRoot);
+        const record = await this.dependencies.questionnaires.get(scope, input.questionnaireId);
+        if (!record ||
+            record.requestKey !== input.requestKey ||
+            record.contentHash !== input.contentHash)
+            throw refuse('Read the exact pending questionnaire before deciding.', 'questionnaire.resume');
+        const externalTaskId = record.owner?.externalTaskId;
+        if (!externalTaskId)
+            throw refuse('This question has no task delegation scope.', 'questionnaire.resume');
+        return this.dependencies.questionnaires.decisions.locked(scope, this.dependencies.client.namespace, externalTaskId, async () => {
+            const answer = input.answer ?? input.answers;
+            if (!answer || Boolean(input.answer) === Boolean(input.answers))
+                throw refuse('Exactly one of answer or answers is required. Resume the original question.', 'questionnaire.resume');
+            const policy = await this.questionnaireDecisionPolicy(record, answer);
+            if (!policy.delegated || !policy.state || policy.state.version !== input.modeVersion)
+                throw refuse('The current mode requires a native answer for this decision, or its version changed. Resume the question.', 'questionnaire.resume');
+            await this.assertDecisionCurrent(record);
+            const reasoning = delegatedReasonSchema.parse({
+                reason: input.reason,
+                alternativesConsidered: input.alternativesConsidered,
+                userInterestReview: input.userInterestReview,
+            });
+            const resolved = await this.dependencies.questionnaires.accept(scope, record.questionnaireId, record.requestKey, answer, {
+                kind: 'delegated_agent',
+                externalTaskId,
+                mode: policy.state.mode,
+                modeVersion: policy.state.version,
+                namespace: this.dependencies.client.namespace,
+                impact: policy.impact,
+                ...reasoning,
+            });
+            return {
+                ...resolved,
+                retry: this.questionnaireRetry(resolved.record, input.repoRoot ?? process.cwd()),
+            };
+        });
+    }
     async questionnaireAsk(input, previousDefinitions = [], owner) {
         const scope = await this.questionnaireScope(input.repoRoot, input.preparation);
         const { repoRoot: _repoRoot, preparation: _preparation, presentation: _presentation, ...definition } = input;
@@ -64,6 +262,7 @@ export class BridgeService {
             ? null
             : await this.checkoutTask(scope.repoFingerprint, await this.dependencies.repositories.git.findRoot(input.repoRoot ?? process.cwd()));
         const record = await this.dependencies.questionnaires.ask(scope, definition, previousDefinitions, owner ?? (askingTask ? { tool: 'questionnaire.ask', externalTaskId: askingTask } : undefined));
+        await this.assertDecisionCurrent(record);
         return { ...record, language: record.language ?? (await this.language()) };
     }
     async checkoutTask(repoFingerprint, repoRoot) {
@@ -80,6 +279,7 @@ export class BridgeService {
         const record = await this.dependencies.questionnaires.get(scope, input.questionnaireId);
         if (!record)
             throw refuse('No questionnaire exists for this account and repository binding.', 'session.entry');
+        await this.assertDecisionCurrent(record);
         return { ...record, language: record.language ?? (await this.language()) };
     }
     async questionnaireWithdraw(input) {
@@ -96,7 +296,7 @@ export class BridgeService {
     async acceptWithScope(scope, questionnaireId, requestKey, answer, answerSource) {
         return this.dependencies.questionnaires.accept(scope, questionnaireId, requestKey, answer, answerSource);
     }
-    retryHint(record, repoRoot, attemptOffset = 0) {
+    questionnaireRetry(record, repoRoot, attemptOffset = 0) {
         if (!record.owner || record.owner.tool === 'questionnaire.ask')
             return undefined;
         const attempt = (record.owner.decisionAttempt ?? 0) + attemptOffset;
@@ -121,7 +321,7 @@ export class BridgeService {
         const resolved = await this.acceptWithScope(scope, input.questionnaireId, input.requestKey, (input.answer ?? input.answers), { kind: 'host_native_relay', hostTool: input.hostTool });
         return {
             ...resolved,
-            retry: this.retryHint(resolved.record, input.repoRoot ?? process.cwd()),
+            retry: this.questionnaireRetry(resolved.record, input.repoRoot ?? process.cwd()),
         };
     }
     async questionnaireScope(repoRoot, preparation = false) {
@@ -227,7 +427,7 @@ export class BridgeService {
             .map(([externalTaskId, record]) => asJsonValue({
             externalTaskId,
             deferredAt: record.answeredAt ?? record.createdAt,
-            reconsider: this.retryHint(record, repoRoot, 1),
+            reconsider: this.questionnaireRetry(record, repoRoot, 1),
             nextAction: `Starting ${externalTaskId} is on hold. Mention it only if the user brings that task up, and call reconsider only when they ask to start it.`,
         }));
         return { mine, other, deferred };
@@ -415,6 +615,10 @@ export class BridgeService {
             await this.seedResumeSnapshot(pointer, data);
             return asJsonValue({
                 ...data,
+                decisionMode: await this.decisionModeStatus({
+                    repoRoot: repository.repoRoot,
+                    externalTaskId: input.externalTaskId,
+                }),
                 checkpoint: checkpointView(checkpoint),
                 repository: publicRepository(repository),
                 localJournal: journalSummary(await this.dependencies.journal.load(projectId, input.externalTaskId)),
@@ -774,6 +978,10 @@ export class BridgeService {
             return asJsonValue({
                 backend: resumeBackendView(backend, backendFresh || !localJournal.projection),
                 requirements: backend.requirements ?? null,
+                decisionMode: await this.decisionModeStatus({
+                    repoRoot: repository.repoRoot,
+                    externalTaskId: taskSlug,
+                }),
                 ...(contextRefreshRequired
                     ? {
                         staleReason: backend.staleReason ?? null,
@@ -1250,6 +1458,8 @@ export class BridgeService {
                 const question = input.questionnaireId
                     ? await this.dependencies.questionnaires.get(scope, input.questionnaireId)
                     : null;
+                if (question)
+                    await this.assertDecisionCurrent(question);
                 const digest = sha256(stableStringify(input.choice));
                 if (question?.answer?.choice !== 'approve' ||
                     (question.binding?.choiceDigest !== digest &&
@@ -1341,6 +1551,8 @@ export class BridgeService {
             const digest = sha256(stableStringify(confirmedInput));
             const scope = await this.questionnaireScope(input.repoRoot);
             const question = await this.dependencies.questionnaires.get(scope, questionnaireId);
+            if (question)
+                await this.assertDecisionCurrent(question);
             if (questionnaireId !== 'sync-start-' + digest ||
                 question?.answer?.choice !== 'approve' ||
                 input.ref !== snapshot.commit)
@@ -1706,6 +1918,8 @@ export class BridgeService {
                     return rule;
                 const questionnaireId = ruleDeviationQuestionnaireId(input.taskId, path, rule);
                 const question = await this.dependencies.questionnaires.get(scope, questionnaireId);
+                if (question)
+                    await this.assertDecisionCurrent(question);
                 const choice = question?.status === 'answered' ? question.answer?.choice : undefined;
                 if (choice === 'change')
                     throw refuse(`The user chose to change ${path} so it follows ${rule.resourceKey}. Change the code, then record task.self_review again with that rule as fixed.`, 'task.self_review');
@@ -1717,7 +1931,12 @@ export class BridgeService {
                     deviationApproval: {
                         questionnaireId,
                         answeredAt: question.answeredAt,
-                        hostTool: question.answerSource?.hostTool ?? null,
+                        hostTool: question.answerSource?.kind === 'host_native_relay'
+                            ? question.answerSource.hostTool
+                            : null,
+                        ...(delegatedEvidence(question)
+                            ? { delegatedDecision: delegatedEvidence(question) }
+                            : {}),
                     },
                 };
             })),
@@ -2043,6 +2262,8 @@ export class BridgeService {
                     for (const waiver of waivers) {
                         const questionnaireId = validationWaiverId(input.taskId, waiver.validationId, paths, waiver.reason);
                         const question = await this.dependencies.questionnaires.get(scope, questionnaireId);
+                        if (question)
+                            await this.assertDecisionCurrent(question);
                         if (question?.answer?.choice !== 'waive') {
                             throw refuse(`The user has not agreed to skip the ${waiver.validationId} check for ${samplePaths(paths) || 'this change'} with this reason. Call task.verify with the waiver so the tool asks them, or provide the evidence.`, 'task.verify');
                         }
@@ -2051,7 +2272,14 @@ export class BridgeService {
                             questionnaireId,
                             reason: waiver.reason,
                             paths,
-                            answerSource: question.answerSource?.hostTool ?? 'mcp_form',
+                            answerSource: question.answerSource?.kind === 'delegated_agent'
+                                ? 'delegated_agent'
+                                : question.answerSource?.kind === 'host_native_relay'
+                                    ? question.answerSource.hostTool
+                                    : 'mcp_form',
+                            ...(delegatedEvidence(question)
+                                ? { delegatedDecision: delegatedEvidence(question) }
+                                : {}),
                         });
                     }
                 }
@@ -3077,6 +3305,19 @@ export class BridgeService {
             });
         });
     }
+    async workItemStatuses(input) {
+        return this.execute(async () => {
+            const query = new URLSearchParams({
+                offset: String(input.offset ?? 0),
+                limit: String(input.limit ?? 50),
+            });
+            if (input.includeArchived !== undefined) {
+                query.set('includeArchived', String(input.includeArchived));
+            }
+            const response = await this.dependencies.client.request(`${endpoints.workItemStatuses(input.projectId)}?${query.toString()}`);
+            return asJsonValue(response.data);
+        });
+    }
     async workItemList(input) {
         return await this.execute(async () => {
             const query = new URLSearchParams();
@@ -3089,6 +3330,10 @@ export class BridgeService {
             }
             if (input.includeArchived)
                 query.set('includeArchived', 'true');
+            if (input.offset !== undefined)
+                query.set('offset', String(input.offset));
+            if (input.limit !== undefined)
+                query.set('limit', String(input.limit));
             const suffix = query.size > 0 ? `?${query.toString()}` : '';
             const response = await this.dependencies.client.request(`${endpoints.workItemList(input.projectId)}${suffix}`);
             return asJsonValue({
@@ -3551,30 +3796,15 @@ export class BridgeService {
         }
     }
     async actionableWorkItems(projectId) {
-        const path = `${endpoints.workItemList(projectId)}?limit=100`;
         try {
-            const chosen = await this.workItemPage(`${path}&actionable=true`).catch((error) => {
-                if (error instanceof ApiResponseError && error.httpStatus === 400)
-                    return null;
-                throw error;
-            });
-            if (chosen && chosen.length > 0)
-                return chosen;
-            const every = await this.workItemPage(path);
-            if (chosen && every.some((entry) => objectValue(objectValue(entry)?.projectStatus) !== null))
-                return [];
-            const actionable = new Set(['backlog', 'ready', 'in_progress', 'in_review']);
-            return every.filter((entry) => actionable.has(String(objectValue(entry)?.status)));
+            const response = await this.dependencies.client.request(`${endpoints.workItemList(projectId)}?limit=100&actionable=true`);
+            const items = objectValue(response.data)?.items;
+            return Array.isArray(items) ? items : [];
         }
         catch {
             return [];
         }
     }
-    async workItemPage(path) {
-        const response = await this.dependencies.client.request(path);
-        const items = objectValue(response.data)?.items;
-        return Array.isArray(items) ? items : [];
-    }
     async clientUpdate(authenticated) {
         const installed = this.dependencies.clientVersion;
         if (!authenticated) {
@@ -5418,4 +5648,16 @@ function publicMembership(value) {
     }
     return result;
 }
+function delegatedEvidence(question) {
+    const source = question.answerSource;
+    if (source?.kind !== 'delegated_agent')
+        return undefined;
+    return {
+        mode: source.mode,
+        modeVersion: source.modeVersion,
+        reason: source.reason,
+        alternativesConsidered: source.alternativesConsidered,
+        userInterestReview: source.userInterestReview,
+    };
+}
 //# sourceMappingURL=bridge-service.js.map

package/runtime/dist/src/runtime/decision-mode-store.js

@@ -0,0 +1,88 @@
+import { join } from 'node:path';
+import * as z from 'zod/v4';
+import { readJson, writeJson } from '../utilities/files.js';
+import { sha256, stableStringify } from '../utilities/hash.js';
+import { localMutex } from '../utilities/local-mutex.js';
+export const decisionModeSchema = z.enum(['autonomous', 'approve_for_me', 'ask']);
+export const decisionTaskId = z
+    .string()
+    .min(2)
+    .max(160)
+    .regex(/^[^\r\n]+$/);
+const selectionSchema = z.strictObject({
+    mode: decisionModeSchema,
+    version: z.number().int().positive(),
+    questionnaireId: z.string().min(1).max(100),
+    changedAt: z.string().datetime(),
+});
+const stateSchema = z.strictObject({
+    scopeKey: z.string().regex(/^[0-9a-f]{64}$/),
+    externalTaskId: decisionTaskId,
+    selections: z.array(selectionSchema).min(1),
+});
+export class DecisionModeStore {
+    root;
+    constructor(stateRoot) {
+        this.root = join(stateRoot, 'decision-modes');
+    }
+    identity(scope, namespace, externalTaskId) {
+        decisionTaskId.parse(externalTaskId);
+        return sha256(stableStringify({ scope, namespace, externalTaskId }));
+    }
+    path(scope, namespace, externalTaskId) {
+        return join(this.root, this.identity(scope, namespace, externalTaskId) + '.json');
+    }
+    async read(scope, namespace, externalTaskId) {
+        const history = await this.history(scope, namespace, externalTaskId);
+        const last = history.at(-1);
+        return last
+            ? {
+                externalTaskId,
+                mode: last.mode,
+                version: last.version,
+                configured: true,
+                questionnaireId: last.questionnaireId,
+            }
+            : { externalTaskId, mode: 'ask', version: 0, configured: false };
+    }
+    async history(scope, namespace, externalTaskId) {
+        const key = this.identity(scope, namespace, externalTaskId);
+        const raw = await readJson(this.path(scope, namespace, externalTaskId), this.root);
+        if (!raw)
+            return [];
+        const state = stateSchema.parse(raw);
+        if (state.scopeKey !== key ||
+            state.externalTaskId !== externalTaskId ||
+            state.selections.some((entry, index) => entry.version !== index + 1))
+            throw new Error('Decision mode state does not match this task.');
+        return state.selections;
+    }
+    async locked(scope, namespace, externalTaskId, work) {
+        return localMutex(this.path(scope, namespace, externalTaskId), work);
+    }
+    async select(scope, namespace, externalTaskId, expectedVersion, mode, questionnaireId) {
+        return this.locked(scope, namespace, externalTaskId, async () => {
+            const selections = await this.history(scope, namespace, externalTaskId);
+            const current = await this.read(scope, namespace, externalTaskId);
+            if (current.version === expectedVersion + 1 &&
+                current.questionnaireId === questionnaireId &&
+                current.mode === mode)
+                return current;
+            if (current.version !== expectedVersion)
+                throw new Error('The decision mode changed. Read decision.mode_status and open a new mode question.');
+            selections.push(selectionSchema.parse({
+                mode,
+                version: expectedVersion + 1,
+                questionnaireId,
+                changedAt: new Date().toISOString(),
+            }));
+            await writeJson(this.path(scope, namespace, externalTaskId), {
+                scopeKey: this.identity(scope, namespace, externalTaskId),
+                externalTaskId,
+                selections,
+            }, this.root);
+            return this.read(scope, namespace, externalTaskId);
+        });
+    }
+}
+//# sourceMappingURL=decision-mode-store.js.map

package/runtime/dist/src/runtime/questionnaire-store.js

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { DecisionModeStore, decisionModeSchema } from './decision-mode-store.js';
 import { link, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import * as z from 'zod/v4';
@@ -76,6 +77,7 @@ function attachDefinitionChecks(schema) {
 }
 const questionnaireDefinitionShape = z.strictObject({
     questionnaireId: identifier,
+    impact: z.enum(['routine', 'critical']).optional(),
     message: z.string().trim().min(1).max(2000),
     context: z
         .string()
@@ -149,10 +151,25 @@ export const hostAnswerSchema = z
         .optional(),
 })
     .refine((value) => Boolean(value.answer) !== Boolean(value.answers), 'Exactly one of answer or answers must be set.');
-const answerSourceSchema = z.strictObject({
-    kind: z.literal('host_native_relay'),
-    hostTool: z.enum(['AskUserQuestion', 'request_user_input']),
+export const delegatedReasonSchema = z.strictObject({
+    reason: z.string().trim().min(20).max(1200),
+    alternativesConsidered: z.string().trim().min(20).max(1200),
+    userInterestReview: z.string().trim().min(20).max(1200),
 });
+const answerSourceSchema = z.union([
+    z.strictObject({
+        kind: z.literal('host_native_relay'),
+        hostTool: z.enum(['AskUserQuestion', 'request_user_input']),
+    }),
+    delegatedReasonSchema.extend({
+        kind: z.literal('delegated_agent'),
+        externalTaskId: z.string().min(2).max(160),
+        mode: decisionModeSchema,
+        modeVersion: z.number().int().positive(),
+        namespace: z.string().regex(/^[0-9a-f]{64}$/),
+        impact: z.enum(['routine', 'critical']),
+    }),
+]);
 const storedAnswerSchema = z.strictObject({
     requestKey: z.string().regex(/^questionnaire_[0-9a-f]{64}$/),
     answeredAt: z.string().datetime(),
@@ -237,8 +254,10 @@ export function questionnaireAnswerSchema(record) {
 }
 export class QuestionnaireStore {
     root;
+    decisions;
     constructor(stateRoot) {
         this.root = join(stateRoot, 'questionnaires');
+        this.decisions = new DecisionModeStore(stateRoot);
     }
     async ask(scope, input, previousDefinitions = [], owner) {
         const definition = boundDefinitionSchema.parse(input);
@@ -268,6 +287,10 @@ export class QuestionnaireStore {
             (record.contentHash !== contentHash && !previousHashes.includes(record.contentHash))) {
             throw new Error('Questionnaire id was reused with different content. Resume the original question or use a new id.');
         }
+        if (owner &&
+            record.owner &&
+            (owner.tool !== record.owner.tool || owner.externalTaskId !== record.owner.externalTaskId))
+            throw new Error('This questionnaire belongs to another task or operation. Resume it in its owning task.');
         return record;
     }
     async get(scope, questionnaireId) {
@@ -277,6 +300,7 @@ export class QuestionnaireStore {
         const question = storedQuestionSchema.parse(raw);
         const definition = boundDefinitionSchema.parse({
             questionnaireId: question.questionnaireId,
+            impact: question.impact,
             message: question.message,
             context: question.context,
             example: question.example,

package/skill/SKILL.md

@@ -11,11 +11,13 @@ Read [lifecycle.md](references/lifecycle.md) before acting in a bound repository
 
 Mandatory behavior:
 
-Use the host's native questionnaire for every question to the user, including implementation choices, names, clarification, branch/worktree decisions and delivery. For a required decision, read [questionnaires.md](references/questionnaires.md), then use `questionnaire.ask` to open a durable native MCP form and `questionnaire.resume` to return to the same unanswered question. Never use request_user_input_async for a required decision: it does not wait for an answer. When the durable form is unavailable, use a blocking native control only where the host permits it: request_user_input in Codex or AskUserQuestion in Claude. Never replace the questionnaire with a chat instruction such as 'type this', 'reply yes', or 'write X if you want Y'. Do not open a survey web page. If the required native control is unavailable or prohibited for that kind of question, follow the host's tool restrictions, explain the limitation, and continue only work already authorized; do not fabricate a survey or silently choose an answer. A timeout, dismissed form, empty response or ended turn is not an answer. Keep the decision pending and resume it; do not start dependent work or report it as resolved. Existing answers remain valid through retries and handoffs.
+Every new task starts with a short native mode selector through task.branch or session.bootstrap: Autonomous, Approve for me (recommended), or Ask for approval. Resume and compaction retain that task's selection. When the user wants to change mode, read decision.mode_status and open decision.mode at its current version. This selector always needs a real native user answer. Autonomous records reasoned agent decisions; Approve for me delegates routine decisions and asks critical ones; Ask for approval asks every required decision. Follow the skill's questionnaires reference and use questionnaire.decide for delegated_decision_required, comparing alternatives and reviewing the user's interests. Never blindly choose the recommendation or relay agent decisions as native answers. Releases, irreversible changes, access, spending, scope expansion and rule exceptions are critical. A mode never overrides host permissions or the normal verification gates.
+
+When the task mode requires a user answer, use the host's native questionnaire for every question to the user, including implementation choices, names, clarification, branch/worktree decisions and delivery. For a required decision, read [questionnaires.md](references/questionnaires.md), then use `questionnaire.ask` to open a durable native MCP form and `questionnaire.resume` to return to the same unanswered question. Never use request_user_input_async for a required decision: it does not wait for an answer. When the durable form is unavailable, use a blocking native control only where the host permits it: request_user_input in Codex or AskUserQuestion in Claude. Never replace the questionnaire with a chat instruction such as 'type this', 'reply yes', or 'write X if you want Y'. Do not open a survey web page. If the required native control is unavailable or prohibited for that kind of question, follow the host's tool restrictions, explain the limitation, and continue only work already authorized; do not fabricate a survey or silently choose an answer. A timeout, dismissed form, empty response or ended turn is not an answer. Keep the decision pending and resume it; do not start dependent work or report it as resolved. Existing answers remain valid through retries and handoffs.
 
 When a durable MCP form cannot be displayed, read its `hostFallback` or call `questionnaire.resume` with `presentation: host_native` to get the original question without reopening the MCP form. Display the same question, all choices and notices through a blocking native control only if the host permits that control for this decision. After an actual native answer, call `questionnaire.answer_from_host` with the unchanged questionnaireId, requestKey and contentHash, the hostTool name and the returned choice/text. This is an agent-reported relay, not MCP transport attestation. Then retry the owning operation; its authority, content and version checks still apply. Never relay prose consent, a default, an asynchronous response or a cancelled/declined/missing answer. Decline alone is not proof that the host cannot display forms. Keep the decision pending if no permitted native control can represent it.
 
-Do not block independent task work on `memory.propose_revision` drafting, submission or approval. Follow [memory-updates.md](references/memory-updates.md): use background agents or concurrent tools when the host permits them and continue useful work; without concurrency, checkpoint the pending draft and defer submission until needed. Wait only at the operation that depends on the proposal or revision. This scheduling rule applies to every project and AI host, while native approval and required task verification remain in force. Apply the same dependency rule to reconciliation, self-review, scaffold receipts, inventory upload, completed-unit evidence and test-result reporting. A bridge result with deliveryStatus pending means durable local recording, so continue independent work without polling or resending. Keep claim acquisition, required approval, edit leases and final verification as real dependencies.
+Do not block independent task work on `memory.propose_revision` drafting, submission or approval. Follow [memory-updates.md](references/memory-updates.md): use background agents or concurrent tools when the host permits them and continue useful work; without concurrency, checkpoint the pending draft and defer submission until needed. Wait only at the operation that depends on the proposal or revision. This scheduling rule applies to every project and AI host, while the selected mode's decision receipt and required task verification remain in force. Apply the same dependency rule to reconciliation, self-review, scaffold receipts, inventory upload, completed-unit evidence and test-result reporting. A bridge result with deliveryStatus pending means durable local recording, so continue independent work without polling or resending. Keep claim acquisition, required approval, edit leases and final verification as real dependencies.
 
 1. Discover the repository binding through `session.entry`. Bindings live in the user-level Engineering Memory state directory, outside the repository and installed runtime. No project settings file is required. For a bound repository, the project's knowledge is in the backend, so answer nothing about it before bootstrapping; the absence of local design files or records says nothing about its stored knowledge.
 2. Call `session.entry` before answering anything in a repository, and act on what it reports before the message itself: sign in when it says so, ask for organization and project when nothing has been decided, and stay completely silent about Engineering Memory in a repository where the user switched it off. Record every one of those answers with `session.set_decision`, and only ever from something the user actually said.
@@ -28,7 +30,7 @@ Do not block independent task work on `memory.propose_revision` drafting, submis
 9. Before validation, read each changed file back against the rules `context.prepare_change` returned for it in `governingRules`, and record `task.self_review` with one entry per changed file naming each of those rules as `follows`, `fixed` or `user_accepted_deviation`. A deviation counts only after the user approves it in the rule-deviation question the bridge asks; matching existing code is not an outcome. Verification refuses without a review of the current diff, and any later edit requires reviewing again.
 10. Run `task.verify` before claiming completion. Write tasks verify the exact Git diff, active lease, and structured command-bound validation evidence. Read-only tasks verify that the current Git diff hash still equals the baseline captured at bootstrap, plus the required discovery, validation, handoff, pinned-context, and synchronization evidence. Run `task.close` only after verification succeeds. Where the pre-commit hook was installed, it confirms the closed task online; a local verification receipt is insufficient. Without the hook nothing checks the commit, so never claim a hook confirmed closure.
 11. After closing a task, settle the delivery question — commit, commit and push, or either of those with a draft or ready pull request onto a base branch the user names — naming the branch, remote and URL the close returned, and do only what they choose. A choice the user already made in their own message is the answer; do not ask it again. When the host's reviewer denies a push or pull request they chose, never use an Engineering Memory form or a typed phrase to get past it; follow the Delivery section of questionnaires.md. Once a pull request exists, check whether it merges cleanly and ask before resolving a conflict.
-12. Never commit, push, publish, deploy, approve a permanent memory revision, or overwrite an existing Git hook without explicit user authorization.
+12. Never commit, push, publish, deploy, approve a permanent memory revision, or overwrite an existing Git hook without explicit user authorization or a valid decision delegated by the selected task mode. Host approval controls still apply.
 13. Never store tokens, passwords, client secrets, raw headers, raw payloads, customer data, or PII in tool inputs, journals, memory, logs, or generated documentation.
 
 If the repository is unbound, do not silently create or attach a project. Use the native questionnaire workflow. If the user selects task-only skip, do not create a binding or memory records.

package/skill/references/lifecycle.md

@@ -1,5 +1,9 @@
 # Mandatory Lifecycle
 
+## Decision mode at task start
+
+Every new task starts with a short native mode selector through task.branch or session.bootstrap: Autonomous, Approve for me (recommended), or Ask for approval. Resume and compaction retain that task's selection. When the user wants to change mode, read decision.mode_status and open decision.mode at its current version. This selector always needs a real native user answer. Autonomous records reasoned agent decisions; Approve for me delegates routine decisions and asks critical ones; Ask for approval asks every required decision. Follow the skill's questionnaires reference and use questionnaire.decide for delegated_decision_required, comparing alternatives and reviewing the user's interests. Never blindly choose the recommendation or relay agent decisions as native answers. Releases, irreversible changes, access, spending, scope expansion and rule exceptions are critical. A mode never overrides host permissions or the normal verification gates.
+
 ## Entry
 
 Sign-in decides nothing beyond who the user is. The organization and the project are chosen after it, through the questionnaires in `questionnaires.md`, and both listings end with an option to create a new one. Ask for both whenever this session has not already confirmed them, and ask again the moment the user says they want to change either — changing the organization always means choosing the project again.
@@ -20,7 +24,7 @@ For a bound repository, call `session.bootstrap` before producing a plan or chan
 
 Before a new write or scaffold task, read `session.entry` and the project Git preferences. If `canManage` is true, and any of development/production/test is still unanswered, ask them through one native form and save them with `project.set_git_preferences` — the tool asks every supplied role as its own question in that single form, then saves the approved roles together in one PUT. Development needs a branch; production/test may explicitly be absent. Their answered flags prevent repeated questions. Other members choose only a task-specific base and continue without changing shared preferences. A later request to change a base updates future tasks only. Branch preferences never label memory sources or change commit/tree applicability.
 
-Start new write or scaffold work with `task.branch`, before `session.bootstrap`, passing the stable `externalTaskId` and `repoRoot`. It opens one short native form with only two questions: the starting branch and the folder. The branch name is generated automatically; a user-requested name may be supplied through `name`. Identical configured remote branches appear once. Folder choices: a separate managed worktree, this folder as a new branch when it is clean (moving out an unfinished task that holds it, which that option names), this folder on its current branch, or not now. Pass `base` or `name` when the user has already specified them; a supplied base removes that question. Do not ask a separate naming question. Keep the form concise and do not repeat its choices in a long chat introduction. Show the whole form in as few native control calls as the host allows, relay every answer together, then call `task.branch` again with the same arguments, which is the `retry` the relay returns. That call allocates exactly what was answered, fetches a remote base and pins its commit, and returns the `repoRoot` to bootstrap in. When the fetch fails it asks once whether to continue from the local commit; never select a cached branch silently. "Not now" returns `status: 'deferred'` with nothing created, reserved or saved: say so in one line, continue only read-only work, and call the returned `reconsider` exactly as given once the user asks to start it. A refusal that names a new `decisionAttempt`, such as a branch name that already exists, asks the form again under that attempt. Existing task decisions survive retries and restarts; resume a recorded branch rather than recreating or resetting it.
+Start new write or scaffold work with `task.branch`, before `session.bootstrap`, passing the stable `externalTaskId` and `repoRoot`. It first opens the three-choice task mode selector. The subsequent start decision asks two short questions, the starting branch and the folder, through a native form or delegated reasoning according to that mode. The branch name is generated automatically; a user-requested name may be supplied through `name`. Identical configured remote branches appear once. Folder choices: a separate managed worktree, this folder as a new branch when it is clean (moving out an unfinished task that holds it, which that option names), this folder on its current branch, or not now. Pass `base` or `name` when the user has already specified them; a supplied base removes that question. Do not ask a separate naming question. Keep the form concise and do not repeat its choices in a long chat introduction. Show the whole form in as few native control calls as the host allows, relay every answer together, then call `task.branch` again with the same arguments, which is the `retry` the relay returns. That call allocates exactly what the native or mode-delegated answer selected, fetches a remote base and pins its commit, and returns the `repoRoot` to bootstrap in. When the fetch fails it asks once whether to continue from the local commit; never select a cached branch silently. "Not now" returns `status: 'deferred'` with nothing created, reserved or saved: say so in one line, continue only read-only work, and call the returned `reconsider` exactly as given once the user asks to start it. A refusal that names a new `decisionAttempt`, such as a branch name that already exists, asks the form again under that attempt. Existing task decisions survive retries and restarts; resume a recorded branch rather than recreating or resetting it.
 
 Use the returned `repoRoot` for **every** file read/write, terminal, context, validation and Git/delivery operation. The user-local pool is shared by Codex and Claude. Managed directories live under `engineering_memory/worktrees/<stable-project-folder>/<folder>_worktreeN`, at the root of the system drive on Windows (`C:\engineering_memory\worktrees\...`) and in the home directory elsewhere, or under the absolute directory named by `worktree-root.json` in the user-level API state directory when that file exists; `worktree.list` reports the effective root, and worktrees created by earlier clients under the Documents folder keep working where they are. Do not supply arbitrary `worktreePath` values or create ad-hoc siblings. Independent clones cannot reuse each other's worktrees. `worktree.list` explains which slots are active, inactive but protected, or safely reusable. The versioned backend policy defaults to 50 directories per project/computer, 30-second heartbeats and 10-minute inactivity. Protected inactive directories still count toward the limit. Only a global admin changes `worktree.set_policy`; it is not an environment setting.
 
@@ -40,7 +44,7 @@ A task nobody is going to finish is abandoned rather than inherited. Ask the use
 
 If an existing task is identified or execution resumes after compaction, call `session.resume`. Reconcile backend sequence, local outbox, Markdown projections, current Git diff, pinned revisions, and the active lease before any further action.
 
-Reconcile pending questions too. A required question remains unanswered across a timeout, dismissed form, interruption or restart. Use `questionnaire.resume` for its recorded identifier and wait for an explicit valid response before dependent work. Follow `questionnaires.md`; do not create a replacement async prompt or consume an unrelated task's answer. A question belongs to the task the chat was working on when it was asked. `pendingQuestionnaires` lists this chat's own questions and those that belong to no task in full; another task's appear under `otherTasksPendingQuestionnaires` as a one-line summary naming that task. Resume one of those only when this chat is working on the task it names.
+Reconcile pending questions too. A required question remains unanswered across a timeout, dismissed form, interruption or restart. Use `questionnaire.resume` for its recorded identifier and follow the current mode for an explicit valid native response or reasoned delegated decision before dependent work. Follow `questionnaires.md`; do not create a replacement async prompt or consume an unrelated task's answer. A question belongs to the task the chat was working on when it was asked. `pendingQuestionnaires` lists this chat's own questions and those that belong to no task in full; another task's appear under `otherTasksPendingQuestionnaires` as a one-line summary naming that task. Resume one of those only when this chat is working on the task it names.
 
 ## Discovery
 
@@ -73,6 +77,14 @@ One WorkItem UUID coordinates independent EngineeringTask runs, one per selected
 
 Open each side with the same workItemId and its own repository binding when work reaches that side. Each side has its own lease, reconciliation, verify, close and commit gate. Check `work_item.runs` and sibling checkpoints when handing off; one side completing does not prove all selected projects are complete. A plan's scope and branch cannot change while an implementation run is active. Read-only analysis does not acquire application write rights; its later write transition must satisfy discipline and the confirmed plan.
 
+### Work item statuses
+
+Read `work_item.statuses` before choosing a status for `work_item.update` or filtering `work_item.list`. The catalogue belongs to the project: follow its user-defined `meaning`, `entryRule` and flags. Never infer workflow from a name or translate statuses into the old six-value set. Send the actual catalogue slug. A work item's `status` is that slug, or null when its status link is invalid.
+
+The catalogue returns `items`, `total`, `offset` and `limit`. Page with `offset` (default 0) and `limit` (default 50, maximum 100); use `includeArchived: true` to inspect retained archived statuses. Each row includes `id`, `slug`, `name`, `category`, `isInitial`, `isActionable`, `isParked`, `isTerminal`, `archivedAt`, `meaning`, `entryRule`, `position` and `lockVersion`. The work item's nested `projectStatus` remains its compact nine-field summary. `work_item.list` also accepts `offset` and `limit`; a status filter matches the actual slug, including retained archived statuses, and an unknown slug returns an empty page. Its `includeArchived` option concerns work items.
+
+Session entry uses the backend's actionable selection. An empty page remains empty, and a failed lookup offers no work items; never retry an unfiltered list to classify statuses locally. Reuse existing user choices. Any unresolved workflow choice must use the native questionnaire.
+
 ### Administration, product management and QA
 
 Administrative authority and work discipline are independent. Organization admins can manage projects, assignments, repository URLs and work items in their organization. A global admin has those rights only in organizations they actively belong to. Ordinary users need a live explicit project assignment. Active organization administrators, including a global admin with live membership in that organization, inherit contributor access to its projects without a separate project grant. Fullstack/backend/web/mobile/frontend disciplines still govern implementation, while project overrides do not grant administration.
@@ -308,7 +320,7 @@ inspection and answer. This recovery never deletes files or branches or interrup
 When a recorded checkout is gone or can no longer be read as a Git worktree — its `.git` was
 deleted, or the repository it was linked to was removed — `worktree.list` names `worktree.reconcile`
 with `forgetUnreadable` and that task's `externalTaskId`, called from a working checkout of the same
-project. After its own native approval Engineering Memory only stops tracking that entry, so it
+project. After its own mode-governed approval Engineering Memory only stops tracking that entry, so it
 stops counting toward the limit; no file in the folder is moved or deleted, the branch and the task
 stay, and a readable checkout is still freed with `worktree.release`.
 

package/skill/references/memory-updates.md

@@ -4,19 +4,23 @@ Backend resources are immutable revisions. The local agent drafts structured con
 
 Use `memory.propose_revision` for project profiles, engineering rules, service contracts, localization contracts, navigation contracts, state contracts, screen logic, component mappings, Figma mappings, current deviations, quality gates, task history, and architecture templates.
 
+## Decision authority
+
+Apply the current task decision mode from the questionnaires reference to proposal decisions too. Autonomous reviews the exact content and records a reasoned delegated choice; Approve for me treats permanent shared memory changes as critical and asks; Ask for approval presents the native question. Neither a worker's report nor a recommendation is an approval. Do not claim an agent decision was a human form response. Existing membership, source, version and verification checks still govern activation.
+
 ## Continue independent work while proposals progress
 
 Do not block independent task work on proposal drafting, submission or approval. This is the usage contract for every project, user and AI host, including Codex and Claude. Decide whether the next operation actually needs the proposal ID or its approved revision; the existence of a pending proposal is not itself a reason to wait.
 
 When the host permits background agents or concurrent tool calls, delegate a bounded set of independent proposals and immediately continue useful work. Collect that worker's result only at a real dependency, rather than spawning a worker and immediately waiting for it. Keep one writer per resource; proposals for different resources may progress together. Keep task-version-changing lifecycle mutations ordered under the owning agent, and handle a resulting version conflict through the normal recovery instead of weakening version checks.
 
-Pass the worker the exact project, task/session and source-run identity that applies, resource identity, baseRevision, verified evidence, proposed selectors and scope. Reuse the owning task's context; delegation neither opens another engineering task nor grants application-edit, approval or delivery authority. Do not pass credentials or claim tokens in prompts or saved documents. The main agent owns native questionnaires and may review or activate a proposal only after the user's explicit decision.
+Pass the worker the exact project, task/session and source-run identity that applies, resource identity, baseRevision, verified evidence, proposed selectors and scope. Reuse the owning task's context; delegation neither opens another engineering task nor grants application-edit, approval or delivery authority. Do not pass credentials or claim tokens in prompts or saved documents. The main agent owns native questionnaires and may review or activate a proposal only after the user's explicit decision or a valid, recorded decision delegated by the current task mode.
 
 If background execution is unavailable or prohibited, preserve the pending draft and its evidence through `task.checkpoint` documents and continue the independent work first. Submit the draft when an operation needs its result. Never claim a background worker exists on a serial-only host or skip the proposal permanently. An approved architectural or flow change that implementation depends on is still a prerequisite for that implementation.
 
 Track each draft, in-flight call, returned proposal ID, queued delivery and failure in the task's checkpoint documents, with its resource/base revision and the bridge-returned delivery identifiers when available. The MCP call still waits for its own real response: `queued: false` reports a stored inactive proposal, while `queued: true` reports a durable outbox entry, not an approved revision. Reuse the existing outbox delivery and its idempotency key through the supported recovery; do not invoke a fresh proposal call merely to retry an already queued one. If the response is lost, use `memory.list_proposals` to check for the exact proposed content before resubmitting. Compare a changed base revision rather than overwriting it.
 
-For example, while a worker records a finished screen's contract, the main agent can inspect an unrelated service or implement an already-approved component. If the next screen needs a changed flow contract, wait for that specific contract's native approval before implementing it. During adoption or refresh, pending proposals for one unit do not stop inspection of independent units. Required proposals, approvals and reconciliations must still be settled before claiming their dependent unit or the whole inspection complete. Unrelated proposal approval never becomes a prerequisite for another task.
+For example, while a worker records a finished screen's contract, the main agent can inspect an unrelated service or implement an already-approved component. If the next screen needs a changed flow contract, wait for that specific contract's mode-governed approval before implementing it. During adoption or refresh, pending proposals for one unit do not stop inspection of independent units. Required proposals, approvals and reconciliations must still be settled before claiming their dependent unit or the whole inspection complete. Unrelated proposal approval never becomes a prerequisite for another task.
 
 Before a dependent reconciliation, verification or handoff, collect the relevant results and report pending or failed work accurately. Do not close or describe unfinished required memory work as complete. A dismissed questionnaire, timeout or deferred submission is not consent.
 

package/skill/references/questionnaires.md

@@ -1,6 +1,24 @@
 # Native Questionnaires
 
-Use the host's native questionnaire for every question to the user, including implementation choices, names, clarification, branch/worktree decisions and delivery. Existing answers remain valid through retries and handoffs. Web pages are limited to sign in, sign up, initial password change, and email verification.
+## Task decision modes
+
+Every new task first opens one short native selector: **Approve for me** (recommended), **Autonomous**, or **Ask for approval**. task.branch does this before its branch/folder decision; session.bootstrap does it for a new read-only task. Do not ask a second custom form. A resumed task keeps its selection; compaction, restart and a write transition are not new tasks.
+
+- **Autonomous**: consider the choices against the user's goals, compare alternatives, independently review the user's interests, and record a reasoned decision. Never blindly select the first or recommended option.
+- **Approve for me**: do the same for routine decisions; ask the user about critical ones.
+- **Ask for approval**: present every required decision natively.
+
+Recognize a request to change mode by meaning, in any language. Read decision.mode_status for the current externalTaskId and call decision.mode with that version as expectedVersion, the same task, repoRoot and conversation language. This opens the same three-choice selector, even while Autonomous is active. Mode selection is always the user's native answer. A comment, explanation request, dismissal or timeout does not select a mode. Do not make the person type a mode name or remember a command.
+
+questionnaire.ask and questionnaire.resume route according to the task's current mode. For reason: delegated_decision_required, inspect all choices and call questionnaire.decide with the exact questionnaireId, requestKey, contentHash and modeVersion plus the chosen answer, reason, alternativesConsidered and userInterestReview. Then retry the owning operation. This is recorded as delegated_agent, never as the user's native answer. Use questionnaire.answer_from_host only for a real permitted blocking native response.
+
+For agent-authored questions, set impact: routine only when the choice stays within authorized scope and is low-impact and reversible. Releases, destructive data changes, access changes, sensitive-file disclosure, added spending, major scope changes and rule/validation exceptions are critical. Omitted impact is critical. Owning operations enforce their own floor: task start can delegate a separate worktree, while moving the current folder or staying on its branch is critical. In Approve for me, use presentation: host_native if the selected option needs critical approval. Never relabel a critical decision to suppress its form.
+
+A mode is local to this account, API origin, repository/project and task. Other tasks and accounts do not inherit it. Changing the mode affects pending and future decisions immediately. An unconsumed agent answer from an older mode version must be re-evaluated with a new question identity (or the owning operation's next decisionAttempt); never replay it as fresh consent. Actual native answers remain valid for their original exact decision. When questionnaire.resume receives a mode answer, execute its returned decision.mode retry to apply the selection. A withdrawn mode question needs a new decisionAttempt with the current expectedVersion.
+
+Modes change who decides, not what the tools can do. Existing membership, source, worktree, lease, validation, release and host-permission checks remain in force. A mode alone skips no check. An explicitly supported validation waiver still uses its exact bound question and normal verification; Autonomous records delegated provenance, Approve for me asks the user. Credentials and browser sign-in continue through their normal interactive flows. Host approval denials cannot be overridden by an EM mode.
+
+When the task mode calls for a user answer, use the host's native questionnaire for every question to the user, including implementation choices, names, clarification, branch/worktree decisions and delivery. Existing answers remain valid through retries and handoffs. Web pages are limited to sign in, sign up, initial password change, and email verification.
 
 ## Required decisions stay pending
 
@@ -26,7 +44,7 @@ one asked before any task started). Every other task's question appears under
 `otherTasksPendingQuestionnaires` as a one-line summary naming its task: enough to recognise,
 never enough to answer here. Resume it only in the chat working on that task.
 
-Only an explicit, valid accepted response answers a question. A timeout, dismissed form, empty response, invalid response, connection loss or ended turn is not an answer. These events leave the decision pending. Never substitute the recommended choice or treat silence as consent. The form's cancel or decline button dismisses the form; if abandoning the work is a meaningful decision, offer it as an explicit answer in the question. A question left pending this way stays pending; show it again once, on the user's next message, and then wait rather than re-asking on every following turn.
+For a native decision, only an explicit, valid accepted response answers the question. A timeout, dismissed form, empty response, invalid response, connection loss or ended turn is not an answer. These events leave the decision pending. Never substitute the recommended choice or treat silence as consent. The form's cancel or decline button dismisses the form; if abandoning the work is a meaningful decision, offer it as an explicit answer in the question. A question left pending this way stays pending; show it again once, on the user's next message, and then wait rather than re-asking on every following turn.
 
 State the decision in `message` and one useful example in `example`, in the language the user is writing in. Never put a resource key, hash, task ID or other internal identifier in a question's text — it explains nothing to the person answering and only makes the question harder to read.