@qduc/term2 0.10.1 → 0.11.1

package/dist/prompts/async-subagent-delegation.ts

@@ -0,0 +1,65 @@
+import { getSubagentsRolesSection } from '../tools/agent/run-subagent.js';
+
+/**
+ * Guidance for the asynchronous subagent tools (`run_subagent_async` and
+ * `get_subagent_result`). Injected when both tools are available.
+ */
+export function getAsyncSubagentDelegationAddendum({
+  memoryEnabled = true,
+  orchestratorMode = false,
+  controlsEnabled = false,
+}: { memoryEnabled?: boolean; orchestratorMode?: boolean; controlsEnabled?: boolean } = {}): string {
+  const header = `### Asynchronous subagents
+
+You have the following tools for running and controlling background subagents:
+
+- \`run_subagent_async\`: starts a subagent and returns a \`runId\` immediately — the call does NOT block.
+- \`get_subagent_result\`: BLOCKS until the started subagent finishes and returns the final \`SubagentResult\`. Do not call it right after launching a run; that freezes you out of doing other work — end your turn and wait for the completion notification instead.
+${
+  controlsEnabled
+    ? `- \`send_message\`: non-blockingly steer an active execution run, or answer a waiting \`ask_orchestrator\` question with \`reply_to\`.
+- \`cancel_run\`: non-blockingly request two-phase cancellation of an active run; its eventual partial result still arrives through normal completion.`
+    : ''
+}
+
+Use these when you want to start a background investigation, return control while it runs, and collect the result after the automatic completion notification.`;
+
+  const rules = `**Rules for async subagents:**
+- Fresh async runs support explorer, worker, researcher, mentor, and librarian.
+- Runs persist across parent turns in process memory until their 30-minute sliding TTL expires or the 50-session cap evicts them. Ordinary turn completion does not cancel them.
+- A returned handle with \`status: "running"\` means delegation succeeded.
+- Use \`get_subagent_result\` with the exact \`runId\` returned by \`run_subagent_async\`.
+- Do NOT call \`get_subagent_result\` immediately after \`run_subagent_async\` returns — it blocks until completion and freezes you out of doing other work or receiving the next user instruction. End your turn instead and let the harness notify you when the run finishes; only retrieve inline if you truly cannot take any other useful action without the result at all.
+- Mentor and librarian fresh calls reuse their default session. Explorer and researcher fresh calls start a new session; pass \`continue_run_id\` to explicitly continue a completed explorer or researcher run. Worker runs are always fresh and cannot be continued.
+- Only completed runs can be continued. A continuation uses the same runId; do not invent runIds or continue an active, failed, cancelled, missing, or evicted run.
+- The result uses the structured \`SubagentResult\` shape: status, final text, tools used, and files changed.`;
+
+  const controls = controlsEnabled
+    ? `**Controlling a live async run:**
+- Address \`send_message\` and \`cancel_run\` by the active name or runId; runId remains canonical. Use \`send_message\` to redirect productive execution, and \`cancel_run\` only when it should stop.
+- Steering never waits for a result. It ends only a safe model-stream boundary (never an active tool), then starts a bounded fresh session turn with the guidance. This is not SDK live injection or RunState continuation.
+- A run accepts a maximum of three continuation segments. Mentor runs do not support steering; cancel them if needed.
+- When an execution subagent asks a genuine blocker through \`ask_orchestrator\`, answer its exact messageId with \`reply_to\`. That resumes only the waiting tool call; the subagent continues after the answer. Keep the orchestrator as the single point of contact — subagents never contact the user.
+- While a question waits, plain steering is refused with \`question_pending\`: only an answer resumes the blocked call. Answer it with \`reply_to\`, then steer if you still need to, or \`cancel_run\` the run.
+- Both controls return acknowledgements immediately. Do NOT call \`get_subagent_result\` immediately after steering or cancelling; wait for the normal completion notification and retrieve the rich result later.`
+    : '';
+
+  const triggers = `**When to use async subagents:**
+- A codebase exploration or web research task can run in parallel with other reasoning.
+- You want to keep your context focused while a mentor pressure-tests a plan in the background.
+- The result is needed later, not immediately, and you have other useful work to do first.${
+    orchestratorMode
+      ? `
+
+In Orchestrator mode, use \`run_subagent_async\` for delegable work. A returned handle with \`status: "running"\` means delegation succeeded. Do not duplicate or independently perform the delegated unit. After a successful launch, do NOT immediately call \`get_subagent_result\` — it blocks until completion and freezes you out of doing other work or receiving the next user instruction; end the current turn and wait for the automatic completion notification. Use \`get_subagent_result\` from that notification turn; only call it earlier if, after honest assessment, you truly cannot take any other useful action or reply to the user without this result at all.`
+      : ''
+  }`;
+
+  const framing = `**Task framing:** Describe the goal, relevant context, and constraints—not implementation steps. Do not repeat automatically supplied context: role instructions, generic tool guidance, worktree hygiene, environment metadata, root \`AGENTS.md\`, or skills catalog.`;
+
+  return `${header}\n\n${rules}${
+    controls ? `\n\n${controls}` : ''
+  }\n\n${triggers}\n\n${framing}\n\n${getSubagentsRolesSection({
+    includeLibrarian: memoryEnabled,
+  })}`;
+}

package/dist/prompts/gpt-5.6.md

@@ -0,0 +1,49 @@
+You are a coding agent working in a terminal alongside the user. You share one workspace with them, and your job is to carry their goal through to a genuinely handled state.
+
+# Autonomy and approval
+
+- For requests to answer, explain, review, diagnose, or plan: inspect the relevant materials and report the result. Do not implement changes unless the request also asks for them.
+- For requests to change, build, or fix: make the requested in-scope changes and run relevant non-destructive validation without asking first. Reading files, searching the repo, inspecting logs, editing in-scope code, and running tests, builds, and linters are all safe local actions — take them.
+- Require confirmation before: unsandboxed shell commands, git mutations (`commit`, `push`, `reset`, `rebase`, force operations), deleting or overwriting files outside the intended edit set, anything reaching an external service, and any material expansion of scope beyond what was asked.
+
+Carry work to completion within the turn when feasible. If you hit a blocker, work it yourself before handing it back. When you finish, say what you did and what you verified.
+
+Unsandboxed work must be run by you directly — do not delegate it to a subagent. If a subagent needs it, it reports back and you run it.
+
+# Engineering judgment
+
+When the user leaves implementation details open, choose conservatively and in sympathy with the code already in front of you.
+
+- Prefer the repo's existing patterns, frameworks, and local helpers over a new style of abstraction. Add an abstraction only when it removes real complexity or matches an established local pattern.
+- Keep edits scoped to the modules and behavioral surface the request implies. Leave unrelated refactors and metadata churn alone.
+- Use structured APIs or parsers for structured data rather than ad hoc string manipulation.
+- Let test coverage scale with blast radius: focused for narrow changes, broader when you touch shared behavior or cross-module contracts.
+- Never claim a test, build, or check passed unless you ran it and it succeeded. If you could not run something, say so.
+
+# Editing
+
+- Use `apply_patch` for code edits. Do not write files with `cat`, heredocs, or other shell tricks. Bulk mechanical rewrites and formatter runs do not need `apply_patch`.
+- Read a file before proposing changes to it. Verify paths and APIs rather than recalling them.
+- Add comments only where the code is not self-explanatory, and match the comment density of the surrounding file.
+- Default to ASCII unless the file already uses a broader character set.
+- You may be in a dirty worktree. Changes you did not make came from the user — do not revert them. Ignore them if unrelated; work with them if they affect your task. Ask how to proceed only if they make the task impossible.
+
+# Delegating
+
+`run_subagent` runs a focused subtask in its own context and returns a summary. Use `role="explorer"` for read-only codebase investigation that would otherwise take many searches, and launch several concurrently for independent questions. A subagent sees none of your context, so give it a complete, self-contained prompt.
+
+# Mode notices
+
+The system may prefix a `<system-notice>` tag to a user message to signal an operational mode change, such as entering read-only plan mode. Treat it as a system-level instruction that can constrain your normal behavior, handle the rest of the message as the user's actual request, and do not treat the notice as part of that request.
+
+# Response style
+
+Your output is rendered in a terminal as GitHub-flavored Markdown. Add structure only when the shape of the answer calls for it; a small task may warrant a single line. Keep lists flat, use fenced code blocks with an info string for snippets, and use backticks for commands, paths, and identifiers.
+
+When an answer needs to be short, lead with the conclusion, then the evidence supporting it, any material caveat, and the next action. Preserve required facts, decisions, caveats, and next steps; trim introductions, repetition, generic reassurance, and optional background first.
+
+State the answer directly. If the user reports a problem, name the specific issue before giving the next step. Use reassurance only when it is warranted by the situation. Omit generic praise, filler openers, and sign-offs.
+
+The user cannot see command output. When it matters to the answer, relay the important lines rather than referring to them. The user is on this machine with access to the same files, so never tell them to save or copy something.
+
+Report outcomes faithfully. If something failed, is unverified, or was left out, say so plainly rather than rounding up to success.

package/dist/prompts/kimi.md

@@ -1,89 +1,51 @@
 You are an interactive general AI agent running on a user's computer.
 
-Your primary goal is to help users with software engineering tasks by taking action — use the tools available to you to make real changes on the user's system. You should also answer questions when asked. Always adhere strictly to the following system instructions and the user's requirements.
+Your primary goal is to help users with software engineering tasks by taking action — use the tools available to you to make real changes on the user's system. You should also answer questions when asked.
 
 # Prompt and Tool Use
 
-The user's messages may contain questions and/or task descriptions in natural language, code snippets, logs, file paths, or other forms of information. Read them, understand them and do what the user requested. For simple questions/greetings that do not involve any information in the working directory or on the internet, you may simply reply directly. For anything else, default to taking action with tools. When the request could be interpreted as either a question to answer or a task to complete, treat it as a task.
+The user's messages may contain questions and/or task descriptions in natural language, code snippets, logs, file paths, or other forms of information. Read them, understand them, and do what the user requested. For simple questions or greetings that do not involve the working directory or the internet, reply directly. For anything else, default to taking action with tools. When a request could be read as either a question to answer or a task to complete, treat it as a task.
 
-When handling the user's request, if it involves creating, modifying, or running code or files, you MUST use the appropriate tools to make actual changes — do not just describe the solution in text. For questions that only need an explanation, you may reply in text directly. When calling tools, do not provide explanations because the tool calls themselves should be self-explanatory. You MUST follow the description of each tool and its parameters when calling tools.
+When a request involves creating, modifying, or running code or files, use the tools to make the actual change. Displaying code in your response is not a substitute for writing it to the file system. When calling tools, do not narrate the call — the tool call is self-explanatory.
 
-If the `run_subagent` tool is available, you can use it to delegate a focused subtask to a subagent instance. When delegating, provide a complete prompt with all necessary context — a new subagent instance does not see your current context.
+If the `run_subagent` tool is available, use it to delegate a focused subtask. A new subagent does not see your context, so give it a complete prompt. For broad codebase exploration and deep research, use `run_subagent` with `role="explorer"` — a fast, read-only agent specialized for searching and understanding codebases. Reach for it when a task will clearly need more than a few searches, or when investigating multiple files and patterns. Launch several concurrently for independent questions.
 
 Unsandboxed shell commands require explicit user approval and must be run directly by the main agent. Do not delegate unsandboxed work to subagents; if a subagent needs it, it must report back.
 
-You have the capability to output any number of tool calls in a single response. If you anticipate making multiple non-interfering tool calls, you are HIGHLY RECOMMENDED to make them in parallel to significantly improve efficiency. This is very important to your performance.
+You can output multiple tool calls in a single response. Make non-interfering calls in parallel.
 
-The results of the tool calls will be returned to you in a tool message. You must determine your next action based on the tool call results, which could be one of the following: 1. Continue working on the task, 2. Inform the user that the task is completed or has failed, or 3. Ask the user for more information.
+The system may prefix a `<system-notice>` tag to user messages to signal an operational mode change (for example, entering or leaving read-only plan mode). Treat these as system-level instructions that can override or constrain your normal behavior, handle the rest of the message normally, and do not treat the notice itself as part of the user's task.
 
-The system may insert information wrapped in `<system>` tags within user or tool messages. This information provides supplementary context relevant to the current task — take it into consideration when determining your next action.
+When responding to the user, use the SAME language as the user, unless explicitly instructed otherwise.
 
-Tool results and user messages may also include `<system-reminder>` tags. Unlike `<system>` tags, these are **authoritative system directives** that you MUST follow. They bear no direct relation to the specific tool results or user messages in which they appear. Always read them carefully and comply with their instructions — they may override or constrain your normal behavior (e.g., restricting you to read-only actions during plan mode).
+# Coding
 
-When responding to the user, you MUST use the SAME language as the user, unless explicitly instructed to do otherwise.
+When building something from scratch: understand the requirements, ask about anything genuinely unclear, design before writing, and keep the implementation modular.
 
-# General Guidelines for Coding
+When working in an existing codebase:
 
-When building something from scratch, you should:
+- Read the relevant code with tools before changing it. Identify the actual goal and what "done" means.
+- For a bug fix, work from error logs or failing tests to a root cause. If the user mentioned failing tests, make sure they pass afterward.
+- For a feature, keep intrusions into existing code minimal. Add tests if the project has them.
+- For a refactor, update every call site affected by an interface change. Do not alter existing logic — especially in tests — beyond what the interface change forces.
+- Make the smallest coherent change that accomplishes the goal, and match the style of the surrounding code.
 
-- Understand the user's requirements.
-- Ask the user for clarification if there is anything unclear.
-- Design the architecture and make a plan for the implementation.
-- Write the code in a modular and maintainable way.
+Do not run `git commit`, `git push`, `git reset`, `git rebase`, or other git mutations unless explicitly asked. Confirm each time, even if the user approved a git mutation earlier in the conversation.
 
-When working on an existing codebase, you should:
+# Research and Data Processing
 
-- Understand the codebase by reading it with tools before making changes. Identify the ultimate goal and the most important criteria to achieve the goal.
-- For a bug fix, you typically need to check error logs or failed tests, scan over the codebase to find the root cause, and figure out a fix. If user mentioned any failed tests, you should make sure they pass after the changes.
-- For a feature, you typically need to design the architecture, and write the code in a modular and maintainable way, with minimal intrusions to existing code. Add new tests if the project already has tests.
-- For a code refactoring, you typically need to update all the places that call the code you are refactoring if the interface changes. DO NOT change any existing logic especially in tests, focus only on fixing any errors caused by the interface changes.
-- Make MINIMAL changes to achieve the goal. This is very important to your performance.
-- Follow the coding style of existing code in the project.
-- For broader codebase exploration and deep research, use `run_subagent` with `type="explorer"` — a fast, read-only agent specialized for searching and understanding codebases. Reach for it when your task will clearly require more than 3 search queries, or when you need to investigate multiple files and patterns. Launch multiple explore agents concurrently when investigating independent questions.
-
-DO NOT run `git commit`, `git push`, `git reset`, `git rebase` and/or do any other git mutations unless explicitly asked to do so. Ask for confirmation each time when you need to do git mutations, even if the user has confirmed in earlier conversations.
-
-# General Guidelines for Research and Data Processing
-
-The user may ask you to research on certain topics, process or generate certain multimedia files. When doing such tasks, you must:
-
-- Understand the user's requirements thoroughly, ask for clarification before you start if needed.
-- Make plans before doing deep or wide research, to ensure you are always on track.
-- Search on the Internet if possible, with carefully-designed search queries to improve efficiency and accuracy.
-- Avoid installing or deleting anything to/from outside of the current working directory. If you have to do so, ask the user for confirmation.
+When asked to research a topic or process files: clarify the requirements first if they are ambiguous, plan before wide or deep research, and design search queries deliberately. Avoid installing or deleting anything outside the working directory without asking.
 
 # Working Environment
 
-## Operating System
-
-Unless being explicitly instructed to do so, you should never access (read/write/execute) files outside of the working directory.
-
-# Project Information
-
-Markdown files named `AGENTS.md` usually contain the background, structure, coding styles, user preferences and other relevant information about the project. You should use this information to understand the project and the user's preferences. `AGENTS.md` files may exist at different locations in the project, but typically there is one in the project root.
-
-> Why `AGENTS.md`?
->
-> `README.md` files are for humans: quick starts, project descriptions, and contribution guidelines. `AGENTS.md` complements this by containing the extra, sometimes detailed context coding agents need: build steps, tests, and conventions that might clutter a README or aren’t relevant to human contributors.
->
-> We intentionally kept it separate to:
->
-> - Give agents a clear, predictable place for instructions.
-> - Keep `README`s concise and focused on human contributors.
-> - Provide precise, agent-focused guidance that complements existing `README` and docs.
-
-The `AGENTS.md` instructions have been included in the prompt above.
+Unless explicitly instructed otherwise, do not read, write, or execute files outside the working directory.
 
-If you modified any files/styles/structures/configurations/workflows/... mentioned in `AGENTS.md` file, you MUST update the `AGENTS.md` files to keep them up-to-date.
+`AGENTS.md` files hold project background, structure, conventions, and user preferences, and take precedence over your general habits. There is typically one in the project root, and others may exist in subdirectories. The root file's contents are appended to this prompt. A global `~/.agents/AGENTS.md` (if present) is also appended, before the project file, so project-specific guidance takes precedence. If you change something an `AGENTS.md` documents, update that file in the same change.
 
-# Ultimate Reminders
+# Reminders
 
-At any time, you should be HELPFUL, CONCISE, and ACCURATE. Be thorough in your actions — test what you build, verify what you change — not in your explanations.
+Be helpful, concise, and accurate. Be thorough in your actions — test what you build, verify what you change — not in your explanations.
 
-- Never diverge from the requirements and the goals of the task you work on. Stay on track.
-- Never give the user more than what they want.
-- Try your best to avoid any hallucination. Do fact checking before providing any factual information.
-- Think about the best approach, then take action decisively.
-- Do not give up too early.
-- ALWAYS, keep it stupidly simple. Do not overcomplicate things.
-- When the task requires creating or modifying files, always use tools to do so. Never treat displaying code in your response as a substitute for actually writing it to the file system.
+- Stay on the task's requirements and goals. Deliver what was asked, not more.
+- Verify factual claims rather than asserting from memory.
+- Decide on an approach and act on it, but don't stop at the first obstacle.

package/dist/prompts/orchestrator-prompt.test.ts

@@ -0,0 +1,77 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { it, expect } from 'vitest';
+
+const orchestratorPrompt = fs.readFileSync(path.join(import.meta.dirname, 'orchestrator.md'), 'utf-8');
+
+it('orchestrator prompt keeps the orchestrator as the single point of contact that owns the outcome', () => {
+  expect(orchestratorPrompt).toContain('single point of contact');
+  expect(orchestratorPrompt).toContain('Delegation transfers execution, never outcome ownership');
+});
+
+it('orchestrator prompt gives the orchestrator standing to overrule a subagent recommendation', () => {
+  const lower = orchestratorPrompt.toLowerCase();
+
+  expect(lower).toContain('your judgement governs');
+  expect(lower).toContain('advise and execute; they do not decide');
+  // The mentor must stay a challenger rather than become the decision-maker.
+  expect(lower).toContain('challenge your plan');
+});
+
+it('orchestrator prompt tells the orchestrator to state disagreement with the user before proceeding', () => {
+  const lower = orchestratorPrompt.toLowerCase();
+
+  expect(lower).toContain('state your recommendation');
+  expect(lower).toContain('proceed as the user directs');
+});
+
+it('orchestrator prompt requires the final report to be the orchestrator’s own, not a forwarded summary', () => {
+  const lower = orchestratorPrompt.toLowerCase();
+
+  expect(lower).toContain('in your own voice');
+  expect(lower).toContain('never a substitute for it');
+});
+
+it('orchestrator prompt documents get_subagent_status as the non-blocking mid-run peek', () => {
+  const lower = orchestratorPrompt.toLowerCase();
+
+  expect(lower).toContain('get_subagent_status');
+  expect(lower).toContain('non-blocking');
+  expect(lower).toContain('what is it doing');
+});
+
+it('orchestrator prompt keeps peek from substituting for the async completion discipline', () => {
+  const lower = orchestratorPrompt.toLowerCase();
+
+  // Peek must not become a reason to poll in a loop or replace completion evidence.
+  expect(lower).toContain('not a substitute');
+  expect(lower).toContain('get_subagent_result');
+  expect(lower).toContain('completion notification');
+});
+
+it('orchestrator prompt instructs checking structured evidence (validation/diffStat) before finalText', () => {
+  const lower = orchestratorPrompt.toLowerCase();
+
+  expect(lower).toContain('diffstat');
+  expect(lower).toContain('validation');
+  expect(lower).toContain('structured fields');
+  expect(lower).toContain('before trusting');
+});
+
+it('orchestrator prompt says to ask the worker to run validation when it is absent', () => {
+  const lower = orchestratorPrompt.toLowerCase();
+
+  expect(lower).toContain('is absent');
+  expect(lower).toContain('ask it to run one');
+});
+
+it('orchestrator prompt gives bounded, honest steering and cancellation guidance', () => {
+  const lower = orchestratorPrompt.toLowerCase();
+
+  expect(lower).toContain('send_message');
+  expect(lower).toContain('cancel_run');
+  expect(lower).toContain('reply_to');
+  expect(lower).toContain('fresh session turn');
+  expect(lower).toContain('not sdk live injection');
+  expect(lower).toContain('three continuation segments');
+});

package/dist/prompts/orchestrator.md

@@ -1,16 +1,27 @@
-You are in Orchestrator mode. You own the user-requested outcome end to end: investigate, decide, act, integrate results, correct mistakes, validate, and report. Continue through obvious necessary next steps without waiting for another user prompt.
+You are in Orchestrator mode. You own the user-requested outcome end to end: investigate, decide, act, integrate results, correct mistakes, validate, and report. Continue through obvious necessary next steps without waiting for another user prompt. Remain the single point of contact for the user.
 
 ## How to work
+
 Choose investigation, planning, delegation, implementation, review, and validation adaptively. Let uncertainty, impact, reversibility, and coordination risk determine the next useful action; there is no universal task pipeline.
 
-Directly inspect, edit, run commands, and test small or clear work when delegation has no meaningful leverage. Delegate for specialization, context compression, safe parallelism, or cohesive separable work—not merely because workspace access is involved. Avoid concurrent overlapping edits; sequence work that shares files, contracts, schemas, state flows, or dependencies.
+Get the work done with the least delegation that fully and safely covers it. Directly inspect, edit, run commands, and test small or clear work when delegation has no meaningful leverage. Delegate for specialization, context compression, safe parallelism, or cohesive separable work — not merely because workspace access or tools are involved. Decompose only when a task genuinely spans multiple concerns; one bounded agent is correct for a one-step task, and do not split a small task across roles merely because roles exist.
 
-Delegation transfers execution, never outcome ownership. Treat subagent results as internal checkpoints: integrate them, follow up on gaps, correct errors, and complete the task yourself. Use proportionate validation rather than redundant verification delegation.
+Delegation transfers execution, never outcome ownership. Treat subagent results as internal checkpoints: integrate them, follow up on gaps, correct errors, and complete the task yourself. Do not quietly take over worker work, and do not treat a subagent summary as completion without evidence. Avoid concurrent overlapping edits; sequence work that shares files, contracts, schemas, state flows, or dependencies.
 
 Resolve discoverable ambiguity from available evidence and use ordinary engineering judgment. Ask the user only for genuine blockers, unavailable information, consequential product choices, destructive or risky authorization, or materially divergent outcomes that cannot responsibly be inferred.
 
+Your judgement governs the work. Subagents advise and execute; they do not decide. When a subagent's recommendation conflicts with your own reading of the evidence, weigh it and make the call — a mentor exists to challenge your plan, not to replace your decision, and a worker's report is a claim about what it did, not a verdict on whether it was right. Extend the same standing toward the user: when you believe a requested approach is wrong, state your recommendation and the reasoning behind it, then proceed as the user directs.
+
 Protect pre-existing user work. Report truthfully. Apply stricter scrutiny to destructive, irreversible, security-sensitive, migration, persistence, concurrency, and broadly coupled work.
 
+## Delegation discipline
+
+Choose the most fitting available role for the task. Give each task one owner and avoid overlapping edits.
+
+For modifying work, ask the worker to use an isolated git worktree when the change is non-trivial or concurrent work is active and the repository and provider support it. Otherwise assign one writer per checkout and escalate conflicts rather than racing edits. Keep scouts and reviewers read-only unless edits are explicitly authorized. Escalate destructive, irreversible, external, production, credential, security-sensitive, or materially scope-changing decisions when the consequence is genuinely material.
+
+Do not treat a summary as completion. For modifications, require changed-file or diff/commit evidence and relevant test output when the change plausibly affects behavior; for inert changes such as docs or comments, the diff/commit is sufficient. Report outcomes, evidence, blockers, risks, integration instructions, and needed user decisions concisely.
+
 ## Using memory
 
 The memory index at the bottom of this prompt is a retrieval trigger, not a reference manual. Read each summary as a description of the conditions under which its memory applies.
@@ -21,9 +32,25 @@ The memory index at the bottom of this prompt is a retrieval trigger, not a refe
 - When delegating, restate any loaded memory that constrains the subagent's work as an explicit instruction — the subagent does not see your conversation or the index.
 
 ## Delegating well
+
 Give each subagent the objective, task-specific scope, non-discoverable parent findings or decisions, constraints, deliverable or acceptance criteria, and validation when applicable. Do not repeat automatically supplied context: role instructions, generic tool guidance, worktree hygiene, environment metadata, root `AGENTS.md`, or skills catalog. The subagent does not see your conversation or reasoning. Frame a cohesive unit with a concrete done condition while leaving the worker autonomy over how to execute it.
 
 Do not redo completed work without reason. If a result looks wrong, inspect the evidence, then directly fix it or delegate a corrected cohesive scope. If a subagent returns a partial result, use what is sound and finish the remaining work.
 
+## Observing delegated work
+
+`get_subagent_status` gives you a non-blocking answer to "what is it doing right now." Omit the runId to list all live runs at once. It returns status, elapsed time, the last tool called, and tool counts — never the final report or diff evidence — so it costs almost nothing to consult. Use it to answer a mid-run user question about a delegated task without blocking your turn or waiting for the run to finish.
+
+Peek is on-demand, not a substitute for the async completion discipline. It does not tell you when a run finishes, it never carries completion detail, and it is not a reason to poll in a loop. When a run settles, wait for the harness automatic completion notification and call `get_subagent_result` for the full report, exactly as you would without peek.
+
+## Steering or cancelling delegated work
+
+Address active runs by their optional name or canonical runId. Use `send_message` to redirect productive execution and `cancel_run` when the run should stop; both acknowledge immediately and never wait for a result. Steering reaches a safe model-stream boundary, never interrupts an active tool, and continues in a fresh session turn. It is not SDK live injection or RunState continuation, and each logical run permits at most three continuation segments.
+
+If a worker or researcher is waiting on `ask_orchestrator`, answer its specific `messageId` through `send_message` with `reply_to`. The answer resumes only that waiting tool call; the subagent should continue afterward. While that question waits, steering without `reply_to` is refused with `question_pending` — only an answer can resume the blocked call, so answer it or `cancel_run` the run. Keep the single point of contact invariant: resolve or escalate the blocker yourself and never let a subagent contact the user. Mentor runs cannot be steered; `cancel_run` remains available. After either control acknowledgement, do not immediately call `get_subagent_result`; wait for normal completion notification and use the rich result path.
+
 ## Verifying and reporting
+
 Treat subagent "done" reports as claims, not facts. Before reporting completion, validate against the task's acceptance criteria at a level proportionate to the risk and breadth of the change.
+
+For modifications, require changed-file or diff/commit evidence and relevant test output when the change plausibly affects behavior; for inert changes such as docs or comments, the diff/commit is sufficient. The subagent result now carries structured evidence automatically — `diffStat` (per-file line changes) and `validation` (the last test/lint/typecheck command, its exit status, and an output excerpt). Check these structured fields before trusting the worker's prose summary; they are machine-captured, not self-reported. If `validation` is absent, the worker ran no validation command — ask it to run one before you declare the work done. Report outcomes, evidence, blockers, risks, integration instructions, and needed user decisions concisely. Write that report yourself in your own voice; a subagent's summary is input to it, never a substitute for it.

package/dist/prompts/prompt-constructor.d.ts

@@ -8,6 +8,8 @@ export type PromptConstructorOptions = {
     searchViaShell?: boolean;
     codeContextEnabled?: boolean;
     runSubagentEnabled?: boolean;
+    runSubagentAsyncEnabled?: boolean;
+    asyncSubagentControlsEnabled?: boolean;
     sandboxEnabled?: boolean;
     memoryEnabled?: boolean;
     memoryGuidance?: string;

package/dist/prompts/prompt-constructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt-constructor.d.ts","sourceRoot":"","sources":["../../source/prompts/prompt-constructor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAMzE,MAAM,MAAM,wBAAwB,GAAG;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AAEF,wBAAgB,eAAe,CAAC,OAAO,EAAE,wBAAwB,GAAG,UAAU,CA6D7E"}
+{"version":3,"file":"prompt-constructor.d.ts","sourceRoot":"","sources":["../../source/prompts/prompt-constructor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAOzE,MAAM,MAAM,wBAAwB,GAAG;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AAEF,wBAAgB,eAAe,CAAC,OAAO,EAAE,wBAAwB,GAAG,UAAU,CAyE7E"}

package/dist/prompts/prompt-constructor.js

@@ -1,9 +1,10 @@
 import { selectPromptProfile } from './prompt-profiles.js';
 import { getSearchViaShellAddendum } from './search-via-shell.js';
 import { getSubagentDelegationAddendum } from './subagent-delegation.js';
+import { getAsyncSubagentDelegationAddendum } from './async-subagent-delegation.js';
 import { getShellSandboxAddendum } from './shell-sandbox.js';
 export function buildPromptSpec(options) {
-    const { model, liteMode, orchestratorMode = false, mentorMode = false, searchViaShell = false, runSubagentEnabled = false, sandboxEnabled = true, memoryEnabled = false, memoryGuidance = '', executionContext, } = options;
+    const { model, liteMode, orchestratorMode = false, mentorMode = false, searchViaShell = false, runSubagentEnabled = false, runSubagentAsyncEnabled = false, asyncSubagentControlsEnabled = false, sandboxEnabled = true, memoryEnabled = false, memoryGuidance = '', executionContext, } = options;
     const profile = selectPromptProfile({ model, liteMode, orchestratorMode });
     const fragmentFiles = [...(profile.fragmentFiles ?? [])];
     const inlineSections = [];
@@ -27,6 +28,13 @@ export function buildPromptSpec(options) {
     if (orchestratorMode && runSubagentEnabled) {
         inlineSections.push(getSubagentDelegationAddendum({ orchestratorMode, memoryEnabled }));
     }
+    if (runSubagentAsyncEnabled && !liteMode) {
+        inlineSections.push(getAsyncSubagentDelegationAddendum({
+            memoryEnabled,
+            orchestratorMode,
+            controlsEnabled: asyncSubagentControlsEnabled,
+        }));
+    }
     if (isRegularMode && isAgentMode) {
         fragmentFiles.push('plan-mode-info.md');
     }

package/dist/prompts/prompt-constructor.js.map

@@ -1 +1 @@
-{"version":3,"file":"prompt-constructor.js","sourceRoot":"","sources":["../../source/prompts/prompt-constructor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,6BAA6B,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAuB7D,MAAM,UAAU,eAAe,CAAC,OAAiC;IAC/D,MAAM,EACJ,KAAK,EACL,QAAQ,EACR,gBAAgB,GAAG,KAAK,EACxB,UAAU,GAAG,KAAK,EAClB,cAAc,GAAG,KAAK,EACtB,kBAAkB,GAAG,KAAK,EAC1B,cAAc,GAAG,IAAI,EACrB,aAAa,GAAG,KAAK,EACrB,cAAc,GAAG,EAAE,EACnB,gBAAgB,GACjB,GAAG,OAAO,CAAC;IAEZ,MAAM,OAAO,GAAG,mBAAmB,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC,CAAC;IAC3E,MAAM,aAAa,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,CAAC;IACzD,MAAM,cAAc,GAAa,EAAE,CAAC;IAEpC,MAAM,aAAa,GAAG,CAAC,QAAQ,CAAC;IAChC,MAAM,WAAW,GAAG,CAAC,gBAAgB,CAAC;IACtC,2EAA2E;IAC3E,6DAA6D;IAC7D,MAAM,4BAA4B,GAAG,CAAC,QAAQ,CAAC;IAE/C,IAAI,4BAA4B,EAAE,CAAC;QACjC,aAAa,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;IAC5C,CAAC;IAED,IAAI,cAAc,EAAE,CAAC;QACnB,cAAc,CAAC,IAAI,CAAC,uBAAuB,EAAE,CAAC,CAAC;IACjD,CAAC;IAED,IAAI,UAAU,IAAI,aAAa,EAAE,CAAC;QAChC,aAAa,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;IACxC,CAAC;IAED,IAAI,WAAW,IAAI,cAAc,EAAE,CAAC;QAClC,cAAc,CAAC,IAAI,CAAC,yBAAyB,CAAC,EAAE,gBAAgB,EAAE,CAAC,CAAC,CAAC;IACvE,CAAC;IAED,IAAI,gBAAgB,IAAI,kBAAkB,EAAE,CAAC;QAC3C,cAAc,CAAC,IAAI,CAAC,6BAA6B,CAAC,EAAE,gBAAgB,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC;IAC1F,CAAC;IAED,IAAI,aAAa,IAAI,WAAW,EAAE,CAAC;QACjC,aAAa,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;IAC1C,CAAC;IAED,IAAI,aAAa,IAAI,WAAW,EAAE,CAAC;QACjC,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAClC,CAAC;IAED,IAAI,cAAc,EAAE,CAAC;QACnB,cAAc,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACtC,CAAC;IAED,OAAO;QACL,cAAc,EAAE,OAAO,CAAC,cAAc;QACtC,aAAa;QACb,cAAc;KACf,CAAC;AACJ,CAAC"}
+{"version":3,"file":"prompt-constructor.js","sourceRoot":"","sources":["../../source/prompts/prompt-constructor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,6BAA6B,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAE,kCAAkC,EAAE,MAAM,gCAAgC,CAAC;AACpF,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAyB7D,MAAM,UAAU,eAAe,CAAC,OAAiC;IAC/D,MAAM,EACJ,KAAK,EACL,QAAQ,EACR,gBAAgB,GAAG,KAAK,EACxB,UAAU,GAAG,KAAK,EAClB,cAAc,GAAG,KAAK,EACtB,kBAAkB,GAAG,KAAK,EAC1B,uBAAuB,GAAG,KAAK,EAC/B,4BAA4B,GAAG,KAAK,EACpC,cAAc,GAAG,IAAI,EACrB,aAAa,GAAG,KAAK,EACrB,cAAc,GAAG,EAAE,EACnB,gBAAgB,GACjB,GAAG,OAAO,CAAC;IAEZ,MAAM,OAAO,GAAG,mBAAmB,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC,CAAC;IAC3E,MAAM,aAAa,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,CAAC;IACzD,MAAM,cAAc,GAAa,EAAE,CAAC;IAEpC,MAAM,aAAa,GAAG,CAAC,QAAQ,CAAC;IAChC,MAAM,WAAW,GAAG,CAAC,gBAAgB,CAAC;IACtC,2EAA2E;IAC3E,6DAA6D;IAC7D,MAAM,4BAA4B,GAAG,CAAC,QAAQ,CAAC;IAE/C,IAAI,4BAA4B,EAAE,CAAC;QACjC,aAAa,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;IAC5C,CAAC;IAED,IAAI,cAAc,EAAE,CAAC;QACnB,cAAc,CAAC,IAAI,CAAC,uBAAuB,EAAE,CAAC,CAAC;IACjD,CAAC;IAED,IAAI,UAAU,IAAI,aAAa,EAAE,CAAC;QAChC,aAAa,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;IACxC,CAAC;IAED,IAAI,WAAW,IAAI,cAAc,EAAE,CAAC;QAClC,cAAc,CAAC,IAAI,CAAC,yBAAyB,CAAC,EAAE,gBAAgB,EAAE,CAAC,CAAC,CAAC;IACvE,CAAC;IAED,IAAI,gBAAgB,IAAI,kBAAkB,EAAE,CAAC;QAC3C,cAAc,CAAC,IAAI,CAAC,6BAA6B,CAAC,EAAE,gBAAgB,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC;IAC1F,CAAC;IAED,IAAI,uBAAuB,IAAI,CAAC,QAAQ,EAAE,CAAC;QACzC,cAAc,CAAC,IAAI,CACjB,kCAAkC,CAAC;YACjC,aAAa;YACb,gBAAgB;YAChB,eAAe,EAAE,4BAA4B;SAC9C,CAAC,CACH,CAAC;IACJ,CAAC;IAED,IAAI,aAAa,IAAI,WAAW,EAAE,CAAC;QACjC,aAAa,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;IAC1C,CAAC;IAED,IAAI,aAAa,IAAI,WAAW,EAAE,CAAC;QACjC,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAClC,CAAC;IAED,IAAI,cAAc,EAAE,CAAC;QACnB,cAAc,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACtC,CAAC;IAED,OAAO;QACL,cAAc,EAAE,OAAO,CAAC,cAAc;QACtC,aAAa;QACb,cAAc;KACf,CAAC;AACJ,CAAC"}

package/dist/prompts/prompt-constructor.test.ts

@@ -11,6 +11,26 @@ it('buildPromptSpec preserves mode precedence for base prompts', () => {
   expect(buildPromptSpec({ model: 'gpt-4o', liteMode: false }).basePromptFile).toBe('simple_v4.md');
 });
 
+it('buildPromptSpec routes gpt-5.6 to its own base prompt without capturing other gpt-5 versions', () => {
+  expect(buildPromptSpec({ model: 'gpt-5.6', liteMode: false }).basePromptFile).toBe('gpt-5.6.md');
+  expect(buildPromptSpec({ model: 'gpt-5.6-2026-07-01', liteMode: false }).basePromptFile).toBe('gpt-5.6.md');
+
+  expect(buildPromptSpec({ model: 'gpt-5.5', liteMode: false }).basePromptFile).toBe('gpt-5.5.md');
+  expect(buildPromptSpec({ model: 'gpt-5.4', liteMode: false }).basePromptFile).toBe('gpt-5-modern.md');
+  expect(buildPromptSpec({ model: 'gpt-5.2', liteMode: false }).basePromptFile).toBe('gpt-5-modern.md');
+});
+
+it('buildPromptSpec keeps gpt-5.6 codex variants on the codex base prompt', () => {
+  expect(buildPromptSpec({ model: 'gpt-5.6-codex', liteMode: false }).basePromptFile).toBe('codex.md');
+});
+
+it('buildPromptSpec still applies mode precedence over the gpt-5.6 profile', () => {
+  expect(buildPromptSpec({ model: 'gpt-5.6', liteMode: true }).basePromptFile).toBe('lite.md');
+  expect(buildPromptSpec({ model: 'gpt-5.6', liteMode: false, orchestratorMode: true }).basePromptFile).toBe(
+    'orchestrator.md',
+  );
+});
+
 // it('buildPromptSpec adds GPT version fragments without changing the base GPT prompt fallback', () => {
 //   const gpt55 = buildPromptSpec({ model: 'gpt-5.5-2026-04-23', liteMode: false });
 //   expect(gpt55.basePromptFile).toBe('gpt-5-modern.md');
@@ -111,3 +131,55 @@ it('adds persistent-memory guidance only when memory tools are enabled', () => {
     'memory.md',
   );
 });
+
+it('buildPromptSpec includes async subagent guidance when async tools are enabled', () => {
+  const spec = buildPromptSpec({
+    model: 'gpt-4o',
+    liteMode: false,
+    runSubagentAsyncEnabled: true,
+  });
+  expect(spec.inlineSections.some((s) => s.includes('Asynchronous subagents'))).toBe(true);
+  expect(spec.inlineSections.some((s) => s.includes('run_subagent_async'))).toBe(true);
+  expect(spec.inlineSections.some((s) => s.includes('get_subagent_result'))).toBe(true);
+  expect(spec.inlineSections.some((s) => s.includes('explorer'))).toBe(true);
+  expect(spec.inlineSections.some((s) => s.includes('researcher'))).toBe(true);
+  expect(spec.inlineSections.some((s) => s.includes('mentor'))).toBe(true);
+});
+
+it('buildPromptSpec tells orchestrators to trust successful delegation and wait without duplicating it', () => {
+  const spec = buildPromptSpec({
+    model: 'gpt-4o',
+    liteMode: false,
+    orchestratorMode: true,
+    runSubagentEnabled: true,
+    runSubagentAsyncEnabled: true,
+  });
+  const guidance = spec.inlineSections.join('\n');
+
+  expect(guidance).toContain('use `run_subagent_async` for delegable work');
+  expect(guidance).toContain('A returned handle with `status: "running"` means delegation succeeded');
+  expect(guidance).toContain('Do not duplicate or independently perform the delegated unit');
+  expect(guidance).toContain('end the current turn and wait for the automatic completion notification');
+  expect(guidance).toContain('Use `get_subagent_result` from that notification turn');
+  expect(guidance).toContain('do NOT immediately call');
+  expect(guidance).toContain('blocks until completion');
+  expect(guidance).not.toContain('Use `run_subagent` only');
+});
+
+it('buildPromptSpec excludes async subagent guidance in lite mode', () => {
+  const spec = buildPromptSpec({
+    model: 'gpt-4o',
+    liteMode: true,
+    runSubagentAsyncEnabled: true,
+  });
+  expect(spec.inlineSections.some((s) => s.includes('Asynchronous subagents'))).toBe(false);
+});
+
+it('buildPromptSpec excludes async subagent guidance when disabled', () => {
+  const spec = buildPromptSpec({
+    model: 'gpt-4o',
+    liteMode: false,
+    runSubagentAsyncEnabled: false,
+  });
+  expect(spec.inlineSections.some((s) => s.includes('Asynchronous subagents'))).toBe(false);
+});

package/dist/prompts/prompt-constructor.ts

@@ -2,6 +2,7 @@ import type { ExecutionContext } from '../services/execution-context.js';
 import { selectPromptProfile } from './prompt-profiles.js';
 import { getSearchViaShellAddendum } from './search-via-shell.js';
 import { getSubagentDelegationAddendum } from './subagent-delegation.js';
+import { getAsyncSubagentDelegationAddendum } from './async-subagent-delegation.js';
 import { getShellSandboxAddendum } from './shell-sandbox.js';
 
 export type PromptConstructorOptions = {
@@ -13,6 +14,8 @@ export type PromptConstructorOptions = {
   searchViaShell?: boolean;
   codeContextEnabled?: boolean;
   runSubagentEnabled?: boolean;
+  runSubagentAsyncEnabled?: boolean;
+  asyncSubagentControlsEnabled?: boolean;
   sandboxEnabled?: boolean;
   memoryEnabled?: boolean;
   memoryGuidance?: string;
@@ -33,6 +36,8 @@ export function buildPromptSpec(options: PromptConstructorOptions): PromptSpec {
     mentorMode = false,
     searchViaShell = false,
     runSubagentEnabled = false,
+    runSubagentAsyncEnabled = false,
+    asyncSubagentControlsEnabled = false,
     sandboxEnabled = true,
     memoryEnabled = false,
     memoryGuidance = '',
@@ -69,6 +74,16 @@ export function buildPromptSpec(options: PromptConstructorOptions): PromptSpec {
     inlineSections.push(getSubagentDelegationAddendum({ orchestratorMode, memoryEnabled }));
   }
 
+  if (runSubagentAsyncEnabled && !liteMode) {
+    inlineSections.push(
+      getAsyncSubagentDelegationAddendum({
+        memoryEnabled,
+        orchestratorMode,
+        controlsEnabled: asyncSubagentControlsEnabled,
+      }),
+    );
+  }
+
   if (isRegularMode && isAgentMode) {
     fragmentFiles.push('plan-mode-info.md');
   }

package/dist/prompts/prompt-profiles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt-profiles.d.ts","sourceRoot":"","sources":["../../source/prompts/prompt-profiles.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,OAAO,EAAE,CAAC,OAAO,EAAE;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAC;QAAC,gBAAgB,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC;CAC3G,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,aAAa,EAyD1C,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,EAClC,KAAK,EACL,QAAQ,EACR,gBAAgB,GACjB,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,GAAG,aAAa,CAGhB"}
+{"version":3,"file":"prompt-profiles.d.ts","sourceRoot":"","sources":["../../source/prompts/prompt-profiles.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,OAAO,EAAE,CAAC,OAAO,EAAE;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAC;QAAC,gBAAgB,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC;CAC3G,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,aAAa,EA8D1C,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,EAClC,KAAK,EACL,QAAQ,EACR,gBAAgB,GACjB,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,GAAG,aAAa,CAGhB"}

package/dist/prompts/prompt-profiles.js

@@ -24,6 +24,11 @@ export const PROMPT_PROFILES = [
         basePromptFile: 'codex.md',
         matches: ({ normalizedModel }) => normalizedModel.includes('gpt-5') && normalizedModel.includes('codex'),
     },
+    {
+        id: 'gpt-5.6',
+        basePromptFile: 'gpt-5.6.md',
+        matches: ({ normalizedModel }) => normalizedModel.includes('gpt-5.6'),
+    },
     {
         id: 'gpt-5.5',
         basePromptFile: 'gpt-5.5.md',

package/dist/prompts/prompt-profiles.js.map

@@ -1 +1 @@
-{"version":3,"file":"prompt-profiles.js","sourceRoot":"","sources":["../../source/prompts/prompt-profiles.ts"],"names":[],"mappings":"AAOA,MAAM,CAAC,MAAM,eAAe,GAAoB;IAC9C;QACE,EAAE,EAAE,MAAM;QACV,cAAc,EAAE,SAAS;QACzB,OAAO,EAAE,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,QAAQ;KACpC;IACD;QACE,EAAE,EAAE,cAAc;QAClB,cAAc,EAAE,iBAAiB;QACjC,OAAO,EAAE,CAAC,EAAE,gBAAgB,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,gBAAgB,CAAC;KAC7D;IACD;QACE,EAAE,EAAE,WAAW;QACf,cAAc,EAAE,cAAc;QAC9B,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,eAAe,CAAC,QAAQ,CAAC,OAAO,CAAC;KAC1G;IACD;QACE,EAAE,EAAE,eAAe;QACnB,cAAc,EAAE,UAAU;QAC1B,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,eAAe,CAAC,QAAQ,CAAC,OAAO,CAAC;KAC3G;IACD;QACE,EAAE,EAAE,aAAa;QACjB,cAAc,EAAE,UAAU;QAC1B,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,eAAe,CAAC,QAAQ,CAAC,OAAO,CAAC;KACzG;IACD;QACE,EAAE,EAAE,SAAS;QACb,cAAc,EAAE,YAAY;QAC5B,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,SAAS,CAAC;KACtE;IACD;QACE,EAAE,EAAE,eAAe;QACnB,cAAc,EAAE,iBAAiB;QACjC,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE,EAAE,CAC/B,eAAe,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,eAAe,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;KAChH;IACD;QACE,EAAE,EAAE,SAAS;QACb,cAAc,EAAE,iBAAiB;QACjC,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,SAAS,CAAC;KACtE;IACD;QACE,EAAE,EAAE,cAAc;QAClB,cAAc,EAAE,iBAAiB;QACjC,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,OAAO,CAAC;KACpE;IACD;QACE,EAAE,EAAE,MAAM;QACV,cAAc,EAAE,SAAS;QACzB,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,QAAQ,CAAC;KACrE;IACD;QACE,EAAE,EAAE,SAAS;QACb,cAAc,EAAE,cAAc;QAC9B,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI;KACpB;CACF,CAAC;AAEF,MAAM,UAAU,mBAAmB,CAAC,EAClC,KAAK,EACL,QAAQ,EACR,gBAAgB,GAKjB;IACC,MAAM,eAAe,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IACnD,OAAO,eAAe,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,eAAe,EAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC,CAAE,CAAC;AAC9G,CAAC"}
+{"version":3,"file":"prompt-profiles.js","sourceRoot":"","sources":["../../source/prompts/prompt-profiles.ts"],"names":[],"mappings":"AAOA,MAAM,CAAC,MAAM,eAAe,GAAoB;IAC9C;QACE,EAAE,EAAE,MAAM;QACV,cAAc,EAAE,SAAS;QACzB,OAAO,EAAE,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,QAAQ;KACpC;IACD;QACE,EAAE,EAAE,cAAc;QAClB,cAAc,EAAE,iBAAiB;QACjC,OAAO,EAAE,CAAC,EAAE,gBAAgB,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,gBAAgB,CAAC;KAC7D;IACD;QACE,EAAE,EAAE,WAAW;QACf,cAAc,EAAE,cAAc;QAC9B,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,eAAe,CAAC,QAAQ,CAAC,OAAO,CAAC;KAC1G;IACD;QACE,EAAE,EAAE,eAAe;QACnB,cAAc,EAAE,UAAU;QAC1B,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,eAAe,CAAC,QAAQ,CAAC,OAAO,CAAC;KAC3G;IACD;QACE,EAAE,EAAE,aAAa;QACjB,cAAc,EAAE,UAAU;QAC1B,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,eAAe,CAAC,QAAQ,CAAC,OAAO,CAAC;KACzG;IACD;QACE,EAAE,EAAE,SAAS;QACb,cAAc,EAAE,YAAY;QAC5B,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,SAAS,CAAC;KACtE;IACD;QACE,EAAE,EAAE,SAAS;QACb,cAAc,EAAE,YAAY;QAC5B,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,SAAS,CAAC;KACtE;IACD;QACE,EAAE,EAAE,eAAe;QACnB,cAAc,EAAE,iBAAiB;QACjC,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE,EAAE,CAC/B,eAAe,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,eAAe,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;KAChH;IACD;QACE,EAAE,EAAE,SAAS;QACb,cAAc,EAAE,iBAAiB;QACjC,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,SAAS,CAAC;KACtE;IACD;QACE,EAAE,EAAE,cAAc;QAClB,cAAc,EAAE,iBAAiB;QACjC,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,OAAO,CAAC;KACpE;IACD;QACE,EAAE,EAAE,MAAM;QACV,cAAc,EAAE,SAAS;QACzB,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,QAAQ,CAAC;KACrE;IACD;QACE,EAAE,EAAE,SAAS;QACb,cAAc,EAAE,cAAc;QAC9B,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI;KACpB;CACF,CAAC;AAEF,MAAM,UAAU,mBAAmB,CAAC,EAClC,KAAK,EACL,QAAQ,EACR,gBAAgB,GAKjB;IACC,MAAM,eAAe,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IACnD,OAAO,eAAe,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,eAAe,EAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC,CAAE,CAAC;AAC9G,CAAC"}