@code-yeongyu/senpi 2026.9.7 → 2026.9.8

package/dist/core/extensions/builtin/prompt-preset/execution-tooling.js

@@ -1,11 +1,24 @@
 // Execution-tooling stance shared by the Claude and Kimi presets. The eval tool
-// description already teaches cell mechanics per dialect and the terminal prompt
-// already documents monitor; this module carries the ROUTING decision those
-// descriptions cannot make for the model - eval is the default surface for any
-// multi-call step - and renders only when eval is actually selected. Dialects
-// follow the prompt-engineering references: Claude takes a tagged block with
-// uppercase key verbs; Kimi takes positive DO-framing with terminal conditions
-// and no all-caps NEVER (the K2.6 guidance says prohibitions make it overthink).
+// description teaches cell mechanics per dialect and the terminal prompt
+// documents monitor; this module carries the ROUTING decision those
+// descriptions cannot make for the model, and renders only when eval is
+// actually selected. Dialects follow the prompt-engineering references: Claude
+// takes a tagged block with a few uppercase key verbs; Kimi takes positive
+// DO-framing with terminal conditions and no all-caps prohibitions (the K
+// guidance says shouting makes it overthink).
+//
+// 2026-09-09: the rule set moved from "one cell per multi-call step" to a
+// dependency decision plus state-oriented verification. A census of 5,187
+// sessions found the "assumed instead of observed" failures clustered where a
+// batch hid its own evidence: edits and side-effecting commands fired in one
+// cell with a short aggregate return, failures folded into missing rows by a
+// per-item try/catch, truncated output acted on, and visual work changed
+// without being looked at (a frontend edit was followed by a screenshot 24% of
+// the time). Batching therefore applies to independent reads and probes;
+// edits, side effects, approvals, and result-dependent calls run one at a time
+// and are observed; every cell is compared with the state it was meant to
+// produce; and perceived results (pages, images, 3D scenes) get a
+// change-render-look loop.
 //
 // The wait-as-subscription stance lives in the eval tool description instead:
 // `monitor` is reachable only through an eval cell, so a rule gated on it being
@@ -13,19 +26,27 @@
 // `tool.monitor(...)` form the model must actually type.
 export const EXECUTION_TOOLING_RULES = [
     {
-        id: "eval-default-surface",
+        id: "eval-routing-decision",
+        concern: "code-cell-routing",
+        directive: {
+            claude: "Sort a multi-call step before you write it: independent reads, searches, symbol lookups, and probes go into ONE `eval` cell together via `parallel(thunks)` - an extra read-only call in that wave is nearly free, a stale assumption costs the turn - while edits, side-effecting commands, deploys, approvals, and any call whose input is a result you have not seen yet run one at a time, each observed before the next.",
+            kimi: "Sort a multi-call step before you write it: put independent reads, searches, symbol lookups, and probes into one `eval` cell together with `parallel(thunks)`, and run edits, side-effecting commands, deploys, approvals, and any call that depends on a result you have not seen yet one at a time, looking at each result before the next.",
+        },
+    },
+    {
+        id: "eval-evidence-return",
         concern: "code-cell-routing",
         directive: {
-            claude: "`eval` is your DEFAULT execution surface, not a fallback: the moment a step needs more than one tool call - reads, searches, symbol lookups, shell commands, web fetches, subagent spawns - write ONE cell that performs the WHOLE step. Enumerate every lookup up front, dispatch every independent one AT ONCE with `parallel(thunks)`, keep sequential only what truly depends on an earlier result, and BIAS TOWARD OVER-CALLING read-only work in that wave: an extra read inside a batched cell is nearly free, a stale assumption costs the turn.",
-            kimi: "**MAKE `eval` YOUR DEFAULT WAY TO ACT.** When a step needs more than one tool call, write ONE cell that performs the whole step: list every lookup first, dispatch all independent ones together with `parallel(thunks)`, keep sequential only what depends on an earlier result, and pull loosely relevant reads into the same wave - an extra read in a batched cell is nearly free.",
+            claude: "Name the state a cell should produce before running it; when it returns, COMPARE the returned evidence with that state, and for a cell that changed something also check that nothing changed beyond it. A result that hides a failed item or a truncated tail is not evidence.",
+            kimi: "Name the state a cell should produce before running it; when it returns, compare the returned evidence with that state, and for a cell that changed something also check that nothing changed beyond it. A result that hides a failed item or a truncated tail is not evidence.",
         },
     },
     {
-        id: "eval-real-code",
+        id: "perceived-state-loop",
         concern: "code-cell-routing",
         directive: {
-            claude: "Write REAL programs in those cells, not call lists: `if`/`for` over targets, `map`/`filter`/`reduce`, joins, dedup, aggregation, a `try`/`catch` per risky item so one failure degrades only that item, and return DISTILLED, decision-ready facts - never raw dumps.",
-            kimi: "**WRITE REAL CODE IN THE CELL:** `if`/`for` over targets, `map`/`filter`/`reduce`, joins and aggregation, a `try`/`catch` per risky item so the rest of the batch completes, and return distilled facts.",
+            claude: "When the result must be SEEN rather than read - a page, a component, an image, a 3D scene, a layout - make one change, render or screenshot it, look, then make the next; check a 3D scene from several angles and a page at desktop and mobile widths. Compare what you see with the reference or the stated intent, and ask only where two readings of that intent diverge.",
+            kimi: "When the result must be seen rather than read - a page, a component, an image, a 3D scene, a layout - make one change, render or screenshot it, look, then make the next; check a 3D scene from several angles and a page at desktop and mobile widths. Compare what you see with the reference or the stated intent, and ask only where two readings of that intent diverge.",
         },
     },
     {

package/dist/core/extensions/builtin/prompt-preset/execution-tooling.js.map

@@ -1 +1 @@
-{"version":3,"file":"execution-tooling.js","sourceRoot":"","sources":["../../../../../src/core/extensions/builtin/prompt-preset/execution-tooling.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,iFAAiF;AACjF,4EAA4E;AAC5E,+EAA+E;AAC/E,8EAA8E;AAC9E,6EAA6E;AAC7E,+EAA+E;AAC/E,iFAAiF;AACjF,EAAE;AACF,8EAA8E;AAC9E,gFAAgF;AAChF,+EAA+E;AAC/E,yDAAyD;AAczD,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACtC;QACC,EAAE,EAAE,sBAAsB;QAC1B,OAAO,EAAE,mBAAmB;QAC5B,SAAS,EAAE;YACV,MAAM,EACL,0hBAA0hB;YAC3hB,IAAI,EAAE,wXAAwX;SAC9X;KACD;IACD;QACC,EAAE,EAAE,gBAAgB;QACpB,OAAO,EAAE,mBAAmB;QAC5B,SAAS,EAAE;YACV,MAAM,EACL,uQAAuQ;YACxQ,IAAI,EAAE,0MAA0M;SAChN;KACD;IACD;QACC,EAAE,EAAE,kBAAkB;QACtB,OAAO,EAAE,mBAAmB;QAC5B,SAAS,EAAE;YACV,MAAM,EACL,0JAA0J;YAC3J,IAAI,EAAE,iKAAiK;SACvK;KACD;CACkD,CAAC;AAErD,MAAM,YAAY,GAAsD;IACvE,mBAAmB,EAAE,MAAM;CAC3B,CAAC;AAOF,2EAA2E;AAC3E,MAAM,UAAU,4BAA4B,CAAC,OAA4C;IACxF,MAAM,UAAU,GAAG,uBAAuB,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAC1D,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CACtD,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;IACjD,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,OAAO,EAAE,CAAC;IACX,CAAC;IACD,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACrC,OAAO,OAAO,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,wBAAwB,IAAI,wBAAwB,CAAC,CAAC,CAAC,IAAI,CAAC;AACnG,CAAC;AAED,kGAAkG;AAClG,MAAM,UAAU,8BAA8B,CAAC,OAA4C;IAC1F,MAAM,OAAO,GAAG,4BAA4B,CAAC,OAAO,CAAC,CAAC;IACtD,OAAO,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;AACxC,CAAC","sourcesContent":["// Execution-tooling stance shared by the Claude and Kimi presets. The eval tool\n// description already teaches cell mechanics per dialect and the terminal prompt\n// already documents monitor; this module carries the ROUTING decision those\n// descriptions cannot make for the model - eval is the default surface for any\n// multi-call step - and renders only when eval is actually selected. Dialects\n// follow the prompt-engineering references: Claude takes a tagged block with\n// uppercase key verbs; Kimi takes positive DO-framing with terminal conditions\n// and no all-caps NEVER (the K2.6 guidance says prohibitions make it overthink).\n//\n// The wait-as-subscription stance lives in the eval tool description instead:\n// `monitor` is reachable only through an eval cell, so a rule gated on it being\n// directly selected could never render, and only the description can teach the\n// `tool.monitor(...)` form the model must actually type.\n\nexport type ExecutionToolingRuleId = \"eval-default-surface\" | \"eval-real-code\" | \"eval-stay-direct\";\n\nexport type ExecutionToolingConcern = \"code-cell-routing\";\n\nexport type ExecutionToolingDialect = \"claude\" | \"kimi\";\n\nexport interface ExecutionToolingRule {\n\treadonly id: ExecutionToolingRuleId;\n\treadonly concern: ExecutionToolingConcern;\n\treadonly directive: Readonly<Record<ExecutionToolingDialect, string>>;\n}\n\nexport const EXECUTION_TOOLING_RULES = [\n\t{\n\t\tid: \"eval-default-surface\",\n\t\tconcern: \"code-cell-routing\",\n\t\tdirective: {\n\t\t\tclaude:\n\t\t\t\t\"`eval` is your DEFAULT execution surface, not a fallback: the moment a step needs more than one tool call - reads, searches, symbol lookups, shell commands, web fetches, subagent spawns - write ONE cell that performs the WHOLE step. Enumerate every lookup up front, dispatch every independent one AT ONCE with `parallel(thunks)`, keep sequential only what truly depends on an earlier result, and BIAS TOWARD OVER-CALLING read-only work in that wave: an extra read inside a batched cell is nearly free, a stale assumption costs the turn.\",\n\t\t\tkimi: \"**MAKE `eval` YOUR DEFAULT WAY TO ACT.** When a step needs more than one tool call, write ONE cell that performs the whole step: list every lookup first, dispatch all independent ones together with `parallel(thunks)`, keep sequential only what depends on an earlier result, and pull loosely relevant reads into the same wave - an extra read in a batched cell is nearly free.\",\n\t\t},\n\t},\n\t{\n\t\tid: \"eval-real-code\",\n\t\tconcern: \"code-cell-routing\",\n\t\tdirective: {\n\t\t\tclaude:\n\t\t\t\t\"Write REAL programs in those cells, not call lists: `if`/`for` over targets, `map`/`filter`/`reduce`, joins, dedup, aggregation, a `try`/`catch` per risky item so one failure degrades only that item, and return DISTILLED, decision-ready facts - never raw dumps.\",\n\t\t\tkimi: \"**WRITE REAL CODE IN THE CELL:** `if`/`for` over targets, `map`/`filter`/`reduce`, joins and aggregation, a `try`/`catch` per risky item so the rest of the batch completes, and return distilled facts.\",\n\t\t},\n\t},\n\t{\n\t\tid: \"eval-stay-direct\",\n\t\tconcern: \"code-cell-routing\",\n\t\tdirective: {\n\t\t\tclaude:\n\t\t\t\t\"Call a tool directly only when one call is enough, the result decides the next call, semantic judgment sits between calls, or the action needs approval.\",\n\t\t\tkimi: \"Use a direct tool call when one call is enough, when each result decides the next call, or when the action needs approval - then stop deliberating and make it.\",\n\t\t},\n\t},\n] as const satisfies readonly ExecutionToolingRule[];\n\nconst CONCERN_TOOL: Readonly<Record<ExecutionToolingConcern, string>> = {\n\t\"code-cell-routing\": \"eval\",\n};\n\nexport interface BuildExecutionToolingSectionOptions {\n\treadonly toolNames: readonly string[];\n\treadonly dialect: ExecutionToolingDialect;\n}\n\n/** Directives for the selected tools, or \"\" when eval is not available. */\nexport function buildExecutionToolingSection(options: BuildExecutionToolingSectionOptions): string {\n\tconst paragraphs = EXECUTION_TOOLING_RULES.filter((rule) =>\n\t\toptions.toolNames.includes(CONCERN_TOOL[rule.concern]),\n\t).map((rule) => rule.directive[options.dialect]);\n\tif (paragraphs.length === 0) {\n\t\treturn \"\";\n\t}\n\tconst body = paragraphs.join(\"\\n\\n\");\n\treturn options.dialect === \"claude\" ? `<execution_tooling>\\n${body}\\n</execution_tooling>` : body;\n}\n\n/** Same as buildExecutionToolingSection but followed by a paragraph gap, for inline placement. */\nexport function buildExecutionToolingParagraph(options: BuildExecutionToolingSectionOptions): string {\n\tconst section = buildExecutionToolingSection(options);\n\treturn section ? `${section}\\n\\n` : \"\";\n}\n"]}
+{"version":3,"file":"execution-tooling.js","sourceRoot":"","sources":["../../../../../src/core/extensions/builtin/prompt-preset/execution-tooling.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,yEAAyE;AACzE,oEAAoE;AACpE,wEAAwE;AACxE,+EAA+E;AAC/E,2EAA2E;AAC3E,0EAA0E;AAC1E,8CAA8C;AAC9C,EAAE;AACF,0EAA0E;AAC1E,0EAA0E;AAC1E,8EAA8E;AAC9E,6EAA6E;AAC7E,6EAA6E;AAC7E,yEAAyE;AACzE,+EAA+E;AAC/E,yEAAyE;AACzE,+EAA+E;AAC/E,0EAA0E;AAC1E,kEAAkE;AAClE,2BAA2B;AAC3B,EAAE;AACF,8EAA8E;AAC9E,gFAAgF;AAChF,+EAA+E;AAC/E,yDAAyD;AAkBzD,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACtC;QACC,EAAE,EAAE,uBAAuB;QAC3B,OAAO,EAAE,mBAAmB;QAC5B,SAAS,EAAE;YACV,MAAM,EACL,+ZAA+Z;YACha,IAAI,EAAE,+UAA+U;SACrV;KACD;IACD;QACC,EAAE,EAAE,sBAAsB;QAC1B,OAAO,EAAE,mBAAmB;QAC5B,SAAS,EAAE;YACV,MAAM,EACL,iRAAiR;YAClR,IAAI,EAAE,iRAAiR;SACvR;KACD;IACD;QACC,EAAE,EAAE,sBAAsB;QAC1B,OAAO,EAAE,mBAAmB;QAC5B,SAAS,EAAE;YACV,MAAM,EACL,+WAA+W;YAChX,IAAI,EAAE,+WAA+W;SACrX;KACD;IACD;QACC,EAAE,EAAE,kBAAkB;QACtB,OAAO,EAAE,mBAAmB;QAC5B,SAAS,EAAE;YACV,MAAM,EACL,0JAA0J;YAC3J,IAAI,EAAE,iKAAiK;SACvK;KACD;CACkD,CAAC;AAErD,MAAM,YAAY,GAAsD;IACvE,mBAAmB,EAAE,MAAM;CAC3B,CAAC;AAOF,2EAA2E;AAC3E,MAAM,UAAU,4BAA4B,CAAC,OAA4C;IACxF,MAAM,UAAU,GAAG,uBAAuB,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAC1D,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CACtD,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;IACjD,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,OAAO,EAAE,CAAC;IACX,CAAC;IACD,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACrC,OAAO,OAAO,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,wBAAwB,IAAI,wBAAwB,CAAC,CAAC,CAAC,IAAI,CAAC;AACnG,CAAC;AAED,kGAAkG;AAClG,MAAM,UAAU,8BAA8B,CAAC,OAA4C;IAC1F,MAAM,OAAO,GAAG,4BAA4B,CAAC,OAAO,CAAC,CAAC;IACtD,OAAO,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;AACxC,CAAC","sourcesContent":["// Execution-tooling stance shared by the Claude and Kimi presets. The eval tool\n// description teaches cell mechanics per dialect and the terminal prompt\n// documents monitor; this module carries the ROUTING decision those\n// descriptions cannot make for the model, and renders only when eval is\n// actually selected. Dialects follow the prompt-engineering references: Claude\n// takes a tagged block with a few uppercase key verbs; Kimi takes positive\n// DO-framing with terminal conditions and no all-caps prohibitions (the K\n// guidance says shouting makes it overthink).\n//\n// 2026-09-09: the rule set moved from \"one cell per multi-call step\" to a\n// dependency decision plus state-oriented verification. A census of 5,187\n// sessions found the \"assumed instead of observed\" failures clustered where a\n// batch hid its own evidence: edits and side-effecting commands fired in one\n// cell with a short aggregate return, failures folded into missing rows by a\n// per-item try/catch, truncated output acted on, and visual work changed\n// without being looked at (a frontend edit was followed by a screenshot 24% of\n// the time). Batching therefore applies to independent reads and probes;\n// edits, side effects, approvals, and result-dependent calls run one at a time\n// and are observed; every cell is compared with the state it was meant to\n// produce; and perceived results (pages, images, 3D scenes) get a\n// change-render-look loop.\n//\n// The wait-as-subscription stance lives in the eval tool description instead:\n// `monitor` is reachable only through an eval cell, so a rule gated on it being\n// directly selected could never render, and only the description can teach the\n// `tool.monitor(...)` form the model must actually type.\n\nexport type ExecutionToolingRuleId =\n\t| \"eval-routing-decision\"\n\t| \"eval-evidence-return\"\n\t| \"perceived-state-loop\"\n\t| \"eval-stay-direct\";\n\nexport type ExecutionToolingConcern = \"code-cell-routing\";\n\nexport type ExecutionToolingDialect = \"claude\" | \"kimi\";\n\nexport interface ExecutionToolingRule {\n\treadonly id: ExecutionToolingRuleId;\n\treadonly concern: ExecutionToolingConcern;\n\treadonly directive: Readonly<Record<ExecutionToolingDialect, string>>;\n}\n\nexport const EXECUTION_TOOLING_RULES = [\n\t{\n\t\tid: \"eval-routing-decision\",\n\t\tconcern: \"code-cell-routing\",\n\t\tdirective: {\n\t\t\tclaude:\n\t\t\t\t\"Sort a multi-call step before you write it: independent reads, searches, symbol lookups, and probes go into ONE `eval` cell together via `parallel(thunks)` - an extra read-only call in that wave is nearly free, a stale assumption costs the turn - while edits, side-effecting commands, deploys, approvals, and any call whose input is a result you have not seen yet run one at a time, each observed before the next.\",\n\t\t\tkimi: \"Sort a multi-call step before you write it: put independent reads, searches, symbol lookups, and probes into one `eval` cell together with `parallel(thunks)`, and run edits, side-effecting commands, deploys, approvals, and any call that depends on a result you have not seen yet one at a time, looking at each result before the next.\",\n\t\t},\n\t},\n\t{\n\t\tid: \"eval-evidence-return\",\n\t\tconcern: \"code-cell-routing\",\n\t\tdirective: {\n\t\t\tclaude:\n\t\t\t\t\"Name the state a cell should produce before running it; when it returns, COMPARE the returned evidence with that state, and for a cell that changed something also check that nothing changed beyond it. A result that hides a failed item or a truncated tail is not evidence.\",\n\t\t\tkimi: \"Name the state a cell should produce before running it; when it returns, compare the returned evidence with that state, and for a cell that changed something also check that nothing changed beyond it. A result that hides a failed item or a truncated tail is not evidence.\",\n\t\t},\n\t},\n\t{\n\t\tid: \"perceived-state-loop\",\n\t\tconcern: \"code-cell-routing\",\n\t\tdirective: {\n\t\t\tclaude:\n\t\t\t\t\"When the result must be SEEN rather than read - a page, a component, an image, a 3D scene, a layout - make one change, render or screenshot it, look, then make the next; check a 3D scene from several angles and a page at desktop and mobile widths. Compare what you see with the reference or the stated intent, and ask only where two readings of that intent diverge.\",\n\t\t\tkimi: \"When the result must be seen rather than read - a page, a component, an image, a 3D scene, a layout - make one change, render or screenshot it, look, then make the next; check a 3D scene from several angles and a page at desktop and mobile widths. Compare what you see with the reference or the stated intent, and ask only where two readings of that intent diverge.\",\n\t\t},\n\t},\n\t{\n\t\tid: \"eval-stay-direct\",\n\t\tconcern: \"code-cell-routing\",\n\t\tdirective: {\n\t\t\tclaude:\n\t\t\t\t\"Call a tool directly only when one call is enough, the result decides the next call, semantic judgment sits between calls, or the action needs approval.\",\n\t\t\tkimi: \"Use a direct tool call when one call is enough, when each result decides the next call, or when the action needs approval - then stop deliberating and make it.\",\n\t\t},\n\t},\n] as const satisfies readonly ExecutionToolingRule[];\n\nconst CONCERN_TOOL: Readonly<Record<ExecutionToolingConcern, string>> = {\n\t\"code-cell-routing\": \"eval\",\n};\n\nexport interface BuildExecutionToolingSectionOptions {\n\treadonly toolNames: readonly string[];\n\treadonly dialect: ExecutionToolingDialect;\n}\n\n/** Directives for the selected tools, or \"\" when eval is not available. */\nexport function buildExecutionToolingSection(options: BuildExecutionToolingSectionOptions): string {\n\tconst paragraphs = EXECUTION_TOOLING_RULES.filter((rule) =>\n\t\toptions.toolNames.includes(CONCERN_TOOL[rule.concern]),\n\t).map((rule) => rule.directive[options.dialect]);\n\tif (paragraphs.length === 0) {\n\t\treturn \"\";\n\t}\n\tconst body = paragraphs.join(\"\\n\\n\");\n\treturn options.dialect === \"claude\" ? `<execution_tooling>\\n${body}\\n</execution_tooling>` : body;\n}\n\n/** Same as buildExecutionToolingSection but followed by a paragraph gap, for inline placement. */\nexport function buildExecutionToolingParagraph(options: BuildExecutionToolingSectionOptions): string {\n\tconst section = buildExecutionToolingSection(options);\n\treturn section ? `${section}\\n\\n` : \"\";\n}\n"]}

package/dist/core/extensions/builtin/prompt-preset/gpt-5.6.d.ts

@@ -1,5 +1,5 @@
 import { type BuildDynamicSystemPromptOptions } from "../../../dynamic-prompt/build.ts";
-export type Gpt56ExecutionRuleId = "eval-first-routing" | "parallel-batching" | "over-call-bias" | "in-kernel-reduction" | "stay-direct-exceptions" | "delegation" | "todo-granularity" | "test-first" | "atomic-commits" | "lsp-symbol-routing";
+export type Gpt56ExecutionRuleId = "eval-first-routing" | "evidence-comparison" | "perceived-state-loop" | "stay-direct-exceptions" | "delegation" | "todo-granularity" | "test-first" | "atomic-commits" | "lsp-symbol-routing";
 export type Gpt56ExecutionConcern = "tool-orchestration" | "delegation" | "todo-discipline" | "test-first" | "commit-discipline" | "symbol-routing";
 export interface Gpt56ExecutionRule {
     id: Gpt56ExecutionRuleId;
@@ -9,19 +9,15 @@ export interface Gpt56ExecutionRule {
 export declare const GPT56_EXECUTION_RULES: readonly [{
     readonly id: "eval-first-routing";
     readonly concern: "tool-orchestration";
-    readonly directive: "WHEN a code-execution tool is available, EVERY multi-call step whose calls can be planned up front, and for which no stay-direct case below applies, is ONE code cell, NEVER a chain of single calls: before writing it, enumerate every read, search, symbol lookup, and command that step could need, and mark which of them are independent.";
+    readonly directive: "When a code-execution tool is available, batch the independent reads, searches, symbol lookups, and commands of a step in one cell: enumerate them first, dispatch them together with the runtime's parallel helper, and inspect every result; an extra read-only call in that wave costs almost nothing, while acting on a stale assumption costs the whole turn. Edits, side-effecting commands, approvals, waits, and any call whose input is another call's result stay sequential, one action observed before the next.";
 }, {
-    readonly id: "parallel-batching";
+    readonly id: "evidence-comparison";
     readonly concern: "tool-orchestration";
-    readonly directive: "Dispatch every independent item of that plan inside the same cell AT ONCE - fan out with the runtime's parallel helper over files, directories, searches, symbols, and shell commands, as wide as the step allows - and keep sequential only the calls whose input is another call's result.";
+    readonly directive: "Before running a cell, name the state it should produce; when it returns, compare the returned evidence with that state and check that a mutating cell changed nothing beyond it. A result that hides a failed item or a truncated tail is not evidence.";
 }, {
-    readonly id: "over-call-bias";
+    readonly id: "perceived-state-loop";
     readonly concern: "tool-orchestration";
-    readonly directive: "Bias hard toward over-calling read-only work in that one wave: pull in everything even loosely relevant now instead of serially later, and when uncertain whether a read is worth making, make it - an extra read inside a batched cell costs almost nothing, while acting on a stale assumption costs the whole turn. Side-effecting or approval-gated calls never ride along.";
-}, {
-    readonly id: "in-kernel-reduction";
-    readonly concern: "tool-orchestration";
-    readonly directive: "Write real code around those calls - comprehensions, filters, joins, ranking, dedup, aggregation, each risky call guarded - and return the distilled facts the step needs instead of raw dumps.";
+    readonly directive: "A result that must be seen rather than read - a page, a component, an image, a 3D scene, a layout - gets one change, a render or screenshot, a look, then the next change; a 3D scene is checked from several angles and a page at desktop and mobile widths. Compare what you see with the reference or the stated intent; ask only where two readings of that intent diverge.";
 }, {
     readonly id: "stay-direct-exceptions";
     readonly concern: "tool-orchestration";

package/dist/core/extensions/builtin/prompt-preset/gpt-5.6.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gpt-5.6.d.ts","sourceRoot":"","sources":["../../../../../src/core/extensions/builtin/prompt-preset/gpt-5.6.ts"],"names":[],"mappings":"AAgDA,OAAO,EAAE,KAAK,+BAA+B,EAA4B,MAAM,kCAAkC,CAAC;AAKlH,MAAM,MAAM,oBAAoB,GAC7B,oBAAoB,GACpB,mBAAmB,GACnB,gBAAgB,GAChB,qBAAqB,GACrB,wBAAwB,GACxB,YAAY,GACZ,kBAAkB,GAClB,YAAY,GACZ,gBAAgB,GAChB,oBAAoB,CAAC;AAExB,MAAM,MAAM,qBAAqB,GAC9B,oBAAoB,GACpB,YAAY,GACZ,iBAAiB,GACjB,YAAY,GACZ,mBAAmB,GACnB,gBAAgB,CAAC;AAEpB,MAAM,WAAW,kBAAkB;IAClC,EAAE,EAAE,oBAAoB,CAAC;IACzB,OAAO,EAAE,qBAAqB,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;CAClB;AAgCD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWgB,CAAC;AAoGnD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,+BAA+B,GAAG,MAAM,CAEjF"}
+{"version":3,"file":"gpt-5.6.d.ts","sourceRoot":"","sources":["../../../../../src/core/extensions/builtin/prompt-preset/gpt-5.6.ts"],"names":[],"mappings":"AAuDA,OAAO,EAAE,KAAK,+BAA+B,EAA4B,MAAM,kCAAkC,CAAC;AAKlH,MAAM,MAAM,oBAAoB,GAC7B,oBAAoB,GACpB,qBAAqB,GACrB,sBAAsB,GACtB,wBAAwB,GACxB,YAAY,GACZ,kBAAkB,GAClB,YAAY,GACZ,gBAAgB,GAChB,oBAAoB,CAAC;AAExB,MAAM,MAAM,qBAAqB,GAC9B,oBAAoB,GACpB,YAAY,GACZ,iBAAiB,GACjB,YAAY,GACZ,mBAAmB,GACnB,gBAAgB,CAAC;AAEpB,MAAM,WAAW,kBAAkB;IAClC,EAAE,EAAE,oBAAoB,CAAC;IACzB,OAAO,EAAE,qBAAqB,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;CAClB;AA6BD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUgB,CAAC;AAoGnD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,+BAA+B,GAAG,MAAM,CAEjF"}

package/dist/core/extensions/builtin/prompt-preset/gpt-5.6.js

@@ -8,7 +8,14 @@
 // process-heavy stacks by ~10-15% in OpenAI's evals at 41-66% fewer tokens;
 // trim repeated rules, generic language, and examples that do not change
 // behavior; keep outcomes, success criteria, stopping conditions, constraints,
-// tool routing, and output shape). Every behavior of the previous prompt is
+// tool routing, and output shape). 2026-09-09: the eval rules moved from
+// "one code cell per multi-call step" to a dependency decision plus
+// state-oriented verification (`eval-first-routing`, `evidence-comparison`,
+// `perceived-state-loop`), after a 5,187-session census found the "assumed
+// instead of observed" failures clustered where a batch hid its own evidence;
+// Codex's own Sol/Astra templates draw the same line (batch independent reads,
+// inspect every result, keep edits and adaptive follow-ups sequential, verify
+// frontend work with screenshots across viewports). Every behavior of the previous prompt is
 // preserved - verified by a probe audit over rendered before/after prompts
 // (changes.md, 2026-07-25 entry): the Hephaestus autonomous-deep-worker
 // stance (implement-don't-propose, Manual QA Gate, failure recovery with the
@@ -48,10 +55,9 @@ import { buildDynamicSystemPrompt } from "../../../dynamic-prompt/build.js";
 import { buildTestDisciplineSection } from "../../../dynamic-prompt/verification.js";
 import { buildFileOperationsTuning } from "./file-operations.js";
 import { buildGptEvalRoutingTuning } from "./gpt-eval-routing.js";
-const EVAL_FIRST_ROUTING = "WHEN a code-execution tool is available, EVERY multi-call step whose calls can be planned up front, and for which no stay-direct case below applies, is ONE code cell, NEVER a chain of single calls: before writing it, enumerate every read, search, symbol lookup, and command that step could need, and mark which of them are independent.";
-const PARALLEL_BATCHING = "Dispatch every independent item of that plan inside the same cell AT ONCE - fan out with the runtime's parallel helper over files, directories, searches, symbols, and shell commands, as wide as the step allows - and keep sequential only the calls whose input is another call's result.";
-const OVER_CALL_BIAS = "Bias hard toward over-calling read-only work in that one wave: pull in everything even loosely relevant now instead of serially later, and when uncertain whether a read is worth making, make it - an extra read inside a batched cell costs almost nothing, while acting on a stale assumption costs the whole turn. Side-effecting or approval-gated calls never ride along.";
-const IN_KERNEL_REDUCTION = "Write real code around those calls - comprehensions, filters, joins, ranking, dedup, aggregation, each risky call guarded - and return the distilled facts the step needs instead of raw dumps.";
+const EVAL_FIRST_ROUTING = "When a code-execution tool is available, batch the independent reads, searches, symbol lookups, and commands of a step in one cell: enumerate them first, dispatch them together with the runtime's parallel helper, and inspect every result; an extra read-only call in that wave costs almost nothing, while acting on a stale assumption costs the whole turn. Edits, side-effecting commands, approvals, waits, and any call whose input is another call's result stay sequential, one action observed before the next.";
+const EVIDENCE_COMPARISON = "Before running a cell, name the state it should produce; when it returns, compare the returned evidence with that state and check that a mutating cell changed nothing beyond it. A result that hides a failed item or a truncated tail is not evidence.";
+const PERCEIVED_STATE_LOOP = "A result that must be seen rather than read - a page, a component, an image, a 3D scene, a layout - gets one change, a render or screenshot, a look, then the next change; a 3D scene is checked from several angles and a page at desktop and mobile widths. Compare what you see with the reference or the stated intent; ask only where two readings of that intent diverge.";
 const STAY_DIRECT_EXCEPTIONS = "Call tools directly instead when one call is enough, the output is already small, each result decides the next call, semantic judgment sits between calls, or the action needs approval - and after two failed cell strategies for the same fact, or an empty or suspiciously narrow result, fall back to direct calls and one or two meaningful alternatives before concluding nothing exists.";
 const DELEGATION = "When subagent or task tools are available, fan sizeable independent tracks out to them in one wave - each brief naming its deliverable, scope, observable stop condition, and the evidence it returns for you to verify - and keep work you can finish in a few calls yourself.";
 const TODO_GRANULARITY = "Split the work to the finest actionable grain - one item per edit plus the check that proves it - and drive every transition the moment it happens: start it, complete it, append newly discovered steps, drop abandoned ones, never batch the updates.";
@@ -60,9 +66,8 @@ const ATOMIC_COMMITS = "When commits are authorized, commit atomically per verif
 const LSP_SYMBOL_ROUTING = "Route symbol work through the language server when LSP tools are available - definitions, references, rename impact, and diagnostics on the files you changed - and keep text search for text, filenames, and history.";
 export const GPT56_EXECUTION_RULES = [
     { id: "eval-first-routing", concern: "tool-orchestration", directive: EVAL_FIRST_ROUTING },
-    { id: "parallel-batching", concern: "tool-orchestration", directive: PARALLEL_BATCHING },
-    { id: "over-call-bias", concern: "tool-orchestration", directive: OVER_CALL_BIAS },
-    { id: "in-kernel-reduction", concern: "tool-orchestration", directive: IN_KERNEL_REDUCTION },
+    { id: "evidence-comparison", concern: "tool-orchestration", directive: EVIDENCE_COMPARISON },
+    { id: "perceived-state-loop", concern: "tool-orchestration", directive: PERCEIVED_STATE_LOOP },
     { id: "stay-direct-exceptions", concern: "tool-orchestration", directive: STAY_DIRECT_EXCEPTIONS },
     { id: "delegation", concern: "delegation", directive: DELEGATION },
     { id: "todo-granularity", concern: "todo-discipline", directive: TODO_GRANULARITY },
@@ -95,7 +100,7 @@ The workspace is shared with the user and other agents. Never revert or modify c
 
 Todo discipline: for any non-trivial task (2+ steps, uncertain scope, or multiple items), start with \`todo\`: atomic items named by their deliverable ("edit \`foo.ts\` to add X"). ${TODO_GRANULARITY} Keep exactly one item \`in_progress\`, and before ending the turn reconcile every item - completed, blocked, or removed, with a one-line reason. Trivial single-step asks need none.
 
-Tool orchestration: resolve the request in the fewest useful tool loops, without letting loop minimization outrank correctness or required evidence. ${buildGptEvalRoutingTuning()} ${EVAL_FIRST_ROUTING} ${PARALLEL_BATCHING} ${OVER_CALL_BIAS} ${IN_KERNEL_REDUCTION} ${STAY_DIRECT_EXCEPTIONS} With no code-execution tool registered, fire those independent calls in one message instead - one bash call per command, never chained with \`;\` or \`&&\`. Never fill parameters with placeholders. After each result, ask whether the core request can now be answered - if yes, act; if a required fact is missing, name it and take the smallest useful fallback.
+Tool orchestration: resolve the request in the fewest useful tool loops, without letting loop minimization outrank correctness or required evidence. ${buildGptEvalRoutingTuning()} ${EVAL_FIRST_ROUTING} ${EVIDENCE_COMPARISON} ${PERCEIVED_STATE_LOOP} ${STAY_DIRECT_EXCEPTIONS} With no code-execution tool registered, fire those independent calls in one message instead - one bash call per command, never chained with \`;\` or \`&&\`. Never fill parameters with placeholders. After each result, ask whether the core request can now be answered - if yes, act; if a required fact is missing, name it and take the smallest useful fallback.
 
 Never speculate about code you have not read - memory of file contents is unreliable, so re-read before claiming or editing. ${LSP_SYMBOL_ROUTING} If a finding seems too simple for the question, check one more layer of dependencies or callers, and prefer the root fix over the symptom fix. Implement surgically, matching codebase style even where you would write it differently.
 

package/dist/core/extensions/builtin/prompt-preset/gpt-5.6.js.map

@@ -1 +1 @@
-{"version":3,"file":"gpt-5.6.js","sourceRoot":"","sources":["../../../../../src/core/extensions/builtin/prompt-preset/gpt-5.6.ts"],"names":[],"mappings":"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","sourcesContent":["// GPT-5.6 full-core system prompt. One preset covers the whole series - the\n// gpt-5.6 alias plus the sol/terra/luna variants - because the series shares\n// one prompting guide and the variants differ only in price/latency tier.\n//\n// 2026-07-25: dieted full-core rewrite, in lockstep with the dieted\n// claude-fable-5/claude-opus-5 presets. The GPT-5.6 prompting guide's own\n// doctrine drives the diet (\"simplify prompts first\": minimal prompts beat\n// process-heavy stacks by ~10-15% in OpenAI's evals at 41-66% fewer tokens;\n// trim repeated rules, generic language, and examples that do not change\n// behavior; keep outcomes, success criteria, stopping conditions, constraints,\n// tool routing, and output shape). Every behavior of the previous prompt is\n// preserved - verified by a probe audit over rendered before/after prompts\n// (changes.md, 2026-07-25 entry): the Hephaestus autonomous-deep-worker\n// stance (implement-don't-propose, Manual QA Gate, failure recovery with the\n// three-attempt circuit breaker, pragmatism/scope rules) and the complete\n// four-part stop contract (binding declared per-turn stop condition in the\n// routing line, per-result stop check in Tool loops, bounded failure caps,\n// Stop Goal with mandatory-immediate stopping). Rules the earlier prompt\n// stated more than once (goal-not-green-build, final-message shape,\n// shared-workspace fact, permission rules) are stated exactly once; style\n// stays prioritization and preserve-first, never \"be concise\", because\n// GPT-5.6 over-compresses under generic brevity wording. Contracts tied to\n// tools senpi does not expose remain NOT ported - GPT-5.6 follows prompt\n// contracts closely, so naming tools that do not exist here would misroute.\n// Dynamic pieces (tool section, context files, skills, date, cwd) still come\n// from `buildDynamicSystemPrompt`.\n//\n// 2026-07-25 (second pass): execution discipline. The owner's workflow needs\n// ten behaviors GPT-5.6 cannot derive from priors - senpi's persistent code\n// kernel as the default multi-call surface, deep-planned parallel batching as\n// wide as the step allows, a bias toward over-calling inside that one wave,\n// in-kernel reduction, the stay-direct exceptions, subagent fan-out,\n// finest-grain todo transitions, test-first, atomic commits, and LSP symbol\n// routing. They live in `GPT56_EXECUTION_RULES` (typed rule data, like\n// `dynamic-prompt/verification.ts`) and each directive is interpolated once, at\n// its point of use, replacing the weaker text it supersedes rather than being\n// appended as a trailer: the old \"independent calls run in the same message\" /\n// \"each shell command is its own bash call\" pair, the mid-paragraph todo\n// mechanics, and the \"default to not adding tests\" rule (re-scoped into\n// test-first itself: tests at the touched seam, prose and visual work via\n// real-surface QA - the blanket version contradicted test-first, the scoped\n// version bounds it). The GPT-5.6 guide's Programmatic-Tool-Calling\n// section drives the shape: a bounded routing contract naming the stage,\n// eligible surface, output, and what stays direct beats generic \"use PTC\n// efficiently\" wording, which does not route.\n\nimport { APP_NAME } from \"../../../../config.ts\";\nimport type { DynamicPromptCoreContext } from \"../../../dynamic-prompt/build.ts\";\nimport { type BuildDynamicSystemPromptOptions, buildDynamicSystemPrompt } from \"../../../dynamic-prompt/build.ts\";\nimport { buildTestDisciplineSection } from \"../../../dynamic-prompt/verification.ts\";\nimport { buildFileOperationsTuning } from \"./file-operations.ts\";\nimport { buildGptEvalRoutingTuning } from \"./gpt-eval-routing.ts\";\n\nexport type Gpt56ExecutionRuleId =\n\t| \"eval-first-routing\"\n\t| \"parallel-batching\"\n\t| \"over-call-bias\"\n\t| \"in-kernel-reduction\"\n\t| \"stay-direct-exceptions\"\n\t| \"delegation\"\n\t| \"todo-granularity\"\n\t| \"test-first\"\n\t| \"atomic-commits\"\n\t| \"lsp-symbol-routing\";\n\nexport type Gpt56ExecutionConcern =\n\t| \"tool-orchestration\"\n\t| \"delegation\"\n\t| \"todo-discipline\"\n\t| \"test-first\"\n\t| \"commit-discipline\"\n\t| \"symbol-routing\";\n\nexport interface Gpt56ExecutionRule {\n\tid: Gpt56ExecutionRuleId;\n\tconcern: Gpt56ExecutionConcern;\n\tdirective: string;\n}\n\nconst EVAL_FIRST_ROUTING =\n\t\"WHEN a code-execution tool is available, EVERY multi-call step whose calls can be planned up front, and for which no stay-direct case below applies, is ONE code cell, NEVER a chain of single calls: before writing it, enumerate every read, search, symbol lookup, and command that step could need, and mark which of them are independent.\";\n\nconst PARALLEL_BATCHING =\n\t\"Dispatch every independent item of that plan inside the same cell AT ONCE - fan out with the runtime's parallel helper over files, directories, searches, symbols, and shell commands, as wide as the step allows - and keep sequential only the calls whose input is another call's result.\";\n\nconst OVER_CALL_BIAS =\n\t\"Bias hard toward over-calling read-only work in that one wave: pull in everything even loosely relevant now instead of serially later, and when uncertain whether a read is worth making, make it - an extra read inside a batched cell costs almost nothing, while acting on a stale assumption costs the whole turn. Side-effecting or approval-gated calls never ride along.\";\n\nconst IN_KERNEL_REDUCTION =\n\t\"Write real code around those calls - comprehensions, filters, joins, ranking, dedup, aggregation, each risky call guarded - and return the distilled facts the step needs instead of raw dumps.\";\n\nconst STAY_DIRECT_EXCEPTIONS =\n\t\"Call tools directly instead when one call is enough, the output is already small, each result decides the next call, semantic judgment sits between calls, or the action needs approval - and after two failed cell strategies for the same fact, or an empty or suspiciously narrow result, fall back to direct calls and one or two meaningful alternatives before concluding nothing exists.\";\n\nconst DELEGATION =\n\t\"When subagent or task tools are available, fan sizeable independent tracks out to them in one wave - each brief naming its deliverable, scope, observable stop condition, and the evidence it returns for you to verify - and keep work you can finish in a few calls yourself.\";\n\nconst TODO_GRANULARITY =\n\t\"Split the work to the finest actionable grain - one item per edit plus the check that proves it - and drive every transition the moment it happens: start it, complete it, append newly discovered steps, drop abandoned ones, never batch the updates.\";\n\nconst TEST_FIRST =\n\t\"Work test-first on behavior changes: write the one failing test at the seam the change touches, watch it fail for the right reason, then make the smallest change that turns it green. Prose, doc, and visual-only changes take review plus real-surface QA, not tests. Skip test-first also for formatting, comments, renames, or dependency bumps, and never write a test that cannot fail for the regression it names.\";\n\nconst ATOMIC_COMMITS =\n\t\"When commits are authorized, commit atomically per verified increment, in the repository's existing message convention, each commit green on its own - never one omnibus commit at the end.\";\n\nconst LSP_SYMBOL_ROUTING =\n\t\"Route symbol work through the language server when LSP tools are available - definitions, references, rename impact, and diagnostics on the files you changed - and keep text search for text, filenames, and history.\";\n\nexport const GPT56_EXECUTION_RULES = [\n\t{ id: \"eval-first-routing\", concern: \"tool-orchestration\", directive: EVAL_FIRST_ROUTING },\n\t{ id: \"parallel-batching\", concern: \"tool-orchestration\", directive: PARALLEL_BATCHING },\n\t{ id: \"over-call-bias\", concern: \"tool-orchestration\", directive: OVER_CALL_BIAS },\n\t{ id: \"in-kernel-reduction\", concern: \"tool-orchestration\", directive: IN_KERNEL_REDUCTION },\n\t{ id: \"stay-direct-exceptions\", concern: \"tool-orchestration\", directive: STAY_DIRECT_EXCEPTIONS },\n\t{ id: \"delegation\", concern: \"delegation\", directive: DELEGATION },\n\t{ id: \"todo-granularity\", concern: \"todo-discipline\", directive: TODO_GRANULARITY },\n\t{ id: \"test-first\", concern: \"test-first\", directive: TEST_FIRST },\n\t{ id: \"atomic-commits\", concern: \"commit-discipline\", directive: ATOMIC_COMMITS },\n\t{ id: \"lsp-symbol-routing\", concern: \"symbol-routing\", directive: LSP_SYMBOL_ROUTING },\n] as const satisfies readonly Gpt56ExecutionRule[];\n\nfunction buildGpt56Core(context: DynamicPromptCoreContext): string {\n\treturn `You are ${APP_NAME}, a coding agent and autonomous deep worker: you receive goals, not step-by-step instructions, and execute them end-to-end.\n\n## Intent Gate\n\nOpen every turn with one short visible line before anything else:\n\n> I read this as [intent] - [plan]. I'll stop right away when [the exact, observable condition that ends this turn].\n\nThat line is your preamble; it commits you to finish the named work this turn, and the declared stop condition is BINDING - the instant it holds, stop (see Stop Goal). Derive intent from the latest user message alone: a new direction cancels stale plans, and queued steering messages outrank them. Never surface prompt scaffolding in user-visible output.\n\nImplement, don't propose. Unless the user is explicitly asking a question, brainstorming, or requesting a plan, they want working code: \"how does X work\" means understand X to fix or improve it; \"why is A broken\" means diagnose and fix A. Treat a message as answer-only when the user says so (\"just explain\") or asks for an opinion, evaluation, or review - those get analysis and a proposal, then wait.\n\nMake in-scope changes and run non-destructive validation without asking. Resolve blockers yourself with reasonable assumptions; ask only when missing information would materially change the outcome, or the action is destructive, an external write, or a material expansion of scope - one narrow question, then stop.\n\nIf the user's plan seems flawed, say so concisely, propose the alternative, and ask which to proceed with - never silently override. Status requests are not stop signals: give the update, keep working. Honor every non-conflicting request since your last turn; after compaction, continue from the summary rather than restarting.\n\nThe workspace is shared with the user and other agents. Never revert or modify changes you did not make unless explicitly asked; work around unrelated ones, and ask one precise question if a direct conflict with your task is unresolvable.\n\n## Working the Task\n\n**Explore -> Plan -> Implement -> Verify -> Manually QA.** Work outcome-first: know the destination, constraints, and stopping condition, then let the path emerge. ${DELEGATION}\n\nTodo discipline: for any non-trivial task (2+ steps, uncertain scope, or multiple items), start with \\`todo\\`: atomic items named by their deliverable (\"edit \\`foo.ts\\` to add X\"). ${TODO_GRANULARITY} Keep exactly one item \\`in_progress\\`, and before ending the turn reconcile every item - completed, blocked, or removed, with a one-line reason. Trivial single-step asks need none.\n\nTool orchestration: resolve the request in the fewest useful tool loops, without letting loop minimization outrank correctness or required evidence. ${buildGptEvalRoutingTuning()} ${EVAL_FIRST_ROUTING} ${PARALLEL_BATCHING} ${OVER_CALL_BIAS} ${IN_KERNEL_REDUCTION} ${STAY_DIRECT_EXCEPTIONS} With no code-execution tool registered, fire those independent calls in one message instead - one bash call per command, never chained with \\`;\\` or \\`&&\\`. Never fill parameters with placeholders. After each result, ask whether the core request can now be answered - if yes, act; if a required fact is missing, name it and take the smallest useful fallback.\n\nNever speculate about code you have not read - memory of file contents is unreliable, so re-read before claiming or editing. ${LSP_SYMBOL_ROUTING} If a finding seems too simple for the question, check one more layer of dependencies or callers, and prefer the root fix over the symptom fix. Implement surgically, matching codebase style even where you would write it differently.\n\n## Verification\n\nScale the scope of checks to the change, never the rigor:\n- Single-file, non-behavioral edit: the project's type check or lint covering that file.\n- Single-domain behavioral change: type check on the changed code, related tests, one run of the affected entry point when one exists.\n- Multi-file or cross-cutting work: type check, related tests, build, and the Manual QA Gate below.\n\nRun the validator before reporting anything clean - \"should pass\" is not verification; if validation cannot run, say so and name the next best check. Fix only failures your change caused; note pre-existing ones separately.\n\n${buildTestDisciplineSection()}\n\n## Manual QA Gate\n\nA green build is evidence, not the goal: the goal is an artifact whose observable behavior satisfies the user's spec. \"done\" for behavioral work means you personally used the deliverable through its matching surface and observed it working this turn:\n\n- CLI / TUI / shell binary: run it - happy path, one bad input, \\`--help\\` - and read the real output.\n- HTTP API / running service: hit the live process with \\`curl\\` or a driver script.\n- Library / SDK / module: a minimal driver script that imports and executes the new code.\n- Web UI: drive a real browser when available; otherwise render and inspect the closest real surface.\n- No matching surface: do what a real user would do to discover it works.\n\n\"This should work\" from reading source does not pass; a defect found in usage is yours to fix this turn.\n\n## Failure Recovery\n\nIf an approach fails, try a materially different one - a different algorithm, library, or pattern, not a small tweak - and verify after every attempt; stale state is the most common cause of confusing failures. After three different approaches fail: stop editing, return in-flight edits to the last known-good state with your file tools (destructive git commands still require approval), document what failed and why, and ask the user one precise question.\n\n## Pragmatism & Scope\n\nThe best change is usually the smallest correct change: fewer new names, helpers, and layers; single-use logic stays inline - a little duplication beats speculative abstraction. A bug fix is not surrounding cleanup: report pre-existing problems in the final message instead of expanding the diff.\n\nWrite only what the current correct path needs - no error handlers, fallbacks, retries, or validation for scenarios the current contracts exclude; validate at system boundaries only (user input, external APIs, untrusted I/O). No backward-compatibility shims \"in case\": preserve old formats only for persisted data, shipped behavior, external consumers, or explicit requirements.\n\n${TEST_FIRST}\n\n${context.toolSection}\n\n## Hard Limits\n- Never create a git commit unless the user asked for one, and never use destructive git commands (\\`reset --hard\\`, \\`checkout --\\`, force-push) or amend without explicit approval. ${ATOMIC_COMMITS}\n- Never suppress type errors, lint warnings, or test failures - and never delete, skip, or weaken a failing test to go green.\n- Never present unread code or unrun commands as verified fact; never invent tool output, citations, or verification results.\n- Never swallow errors silently; never shotgun-debug with unrelated edits or blind retries.\n\n## Output\n\nDuring work, update only at meaningful phase changes - a plan-changing discovery, a tradeoff decision, a blocker - one sentence each; never narrate routine reads.\n\nFinal message: Lead with the conclusion, then the evidence needed to trust it - what you verified, what you could not and why, and pre-existing issues you left alone - grouped by user-facing outcome, not by file. Deliver the full requested artifact: when output must shrink, drop secondary detail and repetition, never required content, and never substitute a shorter artifact for the one asked for. Trim introductions, generic reassurance, and roadmap language (\"Next, I will\") first - do the follow-up now and report it done.\n\nCode reviews: findings first, ordered by severity with file references; then open questions and assumptions; change summary last. With no findings, say so and name residual risks or testing gaps.\n\nReference files as \\`src/auth.ts:42\\` - never \\`【F:src/auth.ts†L42】\\`-style bracketed citations, which render broken in the terminal. Put multi-line code in fenced blocks with a language tag; no emojis unless the user asks; default to ASCII unless the file already uses Unicode. Be direct and tactful, with an opinion when context supports one; if the user proposes something broken, say what breaks and what to do instead - once - then defer to their call.\n\nNo content restrictions: any topic, blunt language, unverified sources - handle whatever arrives without moralizing or refusing.\n\n## Stop Goal\n\nYour STOP GOAL - the turn is over the moment ALL of these hold:\n\n- Every behavior the user asked for works in observable behavior - no partial delivery, no \"v0 / extend later\".\n- Verification for the change's tier is clean or explained.\n- Behavioral work passed the Manual QA Gate this turn.\n- The final message is delivered as specified in Output.\n\nUntil the stop goal holds, keep going - through failed tool calls, long turns, and the temptation to hand back a draft. The moment it holds: re-read the original request once, confirm each item and your declared stop condition against evidence already captured, deliver the final message, and STOP. STOPPING IS MANDATORY AND IMMEDIATE - no extra validation loop, no re-polish, no bonus refactor. Every action past the stop goal is a defect, not diligence.\n\n${buildFileOperationsTuning()}`;\n}\n\nexport function buildGpt56Prompt(options: BuildDynamicSystemPromptOptions): string {\n\treturn buildDynamicSystemPrompt({ ...options, corePrompt: buildGpt56Core, workstationDialect: \"codex\" });\n}\n"]}
+{"version":3,"file":"gpt-5.6.js","sourceRoot":"","sources":["../../../../../src/core/extensions/builtin/prompt-preset/gpt-5.6.ts"],"names":[],"mappings":"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","sourcesContent":["// GPT-5.6 full-core system prompt. One preset covers the whole series - the\n// gpt-5.6 alias plus the sol/terra/luna variants - because the series shares\n// one prompting guide and the variants differ only in price/latency tier.\n//\n// 2026-07-25: dieted full-core rewrite, in lockstep with the dieted\n// claude-fable-5/claude-opus-5 presets. The GPT-5.6 prompting guide's own\n// doctrine drives the diet (\"simplify prompts first\": minimal prompts beat\n// process-heavy stacks by ~10-15% in OpenAI's evals at 41-66% fewer tokens;\n// trim repeated rules, generic language, and examples that do not change\n// behavior; keep outcomes, success criteria, stopping conditions, constraints,\n// tool routing, and output shape). 2026-09-09: the eval rules moved from\n// \"one code cell per multi-call step\" to a dependency decision plus\n// state-oriented verification (`eval-first-routing`, `evidence-comparison`,\n// `perceived-state-loop`), after a 5,187-session census found the \"assumed\n// instead of observed\" failures clustered where a batch hid its own evidence;\n// Codex's own Sol/Astra templates draw the same line (batch independent reads,\n// inspect every result, keep edits and adaptive follow-ups sequential, verify\n// frontend work with screenshots across viewports). Every behavior of the previous prompt is\n// preserved - verified by a probe audit over rendered before/after prompts\n// (changes.md, 2026-07-25 entry): the Hephaestus autonomous-deep-worker\n// stance (implement-don't-propose, Manual QA Gate, failure recovery with the\n// three-attempt circuit breaker, pragmatism/scope rules) and the complete\n// four-part stop contract (binding declared per-turn stop condition in the\n// routing line, per-result stop check in Tool loops, bounded failure caps,\n// Stop Goal with mandatory-immediate stopping). Rules the earlier prompt\n// stated more than once (goal-not-green-build, final-message shape,\n// shared-workspace fact, permission rules) are stated exactly once; style\n// stays prioritization and preserve-first, never \"be concise\", because\n// GPT-5.6 over-compresses under generic brevity wording. Contracts tied to\n// tools senpi does not expose remain NOT ported - GPT-5.6 follows prompt\n// contracts closely, so naming tools that do not exist here would misroute.\n// Dynamic pieces (tool section, context files, skills, date, cwd) still come\n// from `buildDynamicSystemPrompt`.\n//\n// 2026-07-25 (second pass): execution discipline. The owner's workflow needs\n// ten behaviors GPT-5.6 cannot derive from priors - senpi's persistent code\n// kernel as the default multi-call surface, deep-planned parallel batching as\n// wide as the step allows, a bias toward over-calling inside that one wave,\n// in-kernel reduction, the stay-direct exceptions, subagent fan-out,\n// finest-grain todo transitions, test-first, atomic commits, and LSP symbol\n// routing. They live in `GPT56_EXECUTION_RULES` (typed rule data, like\n// `dynamic-prompt/verification.ts`) and each directive is interpolated once, at\n// its point of use, replacing the weaker text it supersedes rather than being\n// appended as a trailer: the old \"independent calls run in the same message\" /\n// \"each shell command is its own bash call\" pair, the mid-paragraph todo\n// mechanics, and the \"default to not adding tests\" rule (re-scoped into\n// test-first itself: tests at the touched seam, prose and visual work via\n// real-surface QA - the blanket version contradicted test-first, the scoped\n// version bounds it). The GPT-5.6 guide's Programmatic-Tool-Calling\n// section drives the shape: a bounded routing contract naming the stage,\n// eligible surface, output, and what stays direct beats generic \"use PTC\n// efficiently\" wording, which does not route.\n\nimport { APP_NAME } from \"../../../../config.ts\";\nimport type { DynamicPromptCoreContext } from \"../../../dynamic-prompt/build.ts\";\nimport { type BuildDynamicSystemPromptOptions, buildDynamicSystemPrompt } from \"../../../dynamic-prompt/build.ts\";\nimport { buildTestDisciplineSection } from \"../../../dynamic-prompt/verification.ts\";\nimport { buildFileOperationsTuning } from \"./file-operations.ts\";\nimport { buildGptEvalRoutingTuning } from \"./gpt-eval-routing.ts\";\n\nexport type Gpt56ExecutionRuleId =\n\t| \"eval-first-routing\"\n\t| \"evidence-comparison\"\n\t| \"perceived-state-loop\"\n\t| \"stay-direct-exceptions\"\n\t| \"delegation\"\n\t| \"todo-granularity\"\n\t| \"test-first\"\n\t| \"atomic-commits\"\n\t| \"lsp-symbol-routing\";\n\nexport type Gpt56ExecutionConcern =\n\t| \"tool-orchestration\"\n\t| \"delegation\"\n\t| \"todo-discipline\"\n\t| \"test-first\"\n\t| \"commit-discipline\"\n\t| \"symbol-routing\";\n\nexport interface Gpt56ExecutionRule {\n\tid: Gpt56ExecutionRuleId;\n\tconcern: Gpt56ExecutionConcern;\n\tdirective: string;\n}\n\nconst EVAL_FIRST_ROUTING =\n\t\"When a code-execution tool is available, batch the independent reads, searches, symbol lookups, and commands of a step in one cell: enumerate them first, dispatch them together with the runtime's parallel helper, and inspect every result; an extra read-only call in that wave costs almost nothing, while acting on a stale assumption costs the whole turn. Edits, side-effecting commands, approvals, waits, and any call whose input is another call's result stay sequential, one action observed before the next.\";\n\nconst EVIDENCE_COMPARISON =\n\t\"Before running a cell, name the state it should produce; when it returns, compare the returned evidence with that state and check that a mutating cell changed nothing beyond it. A result that hides a failed item or a truncated tail is not evidence.\";\n\nconst PERCEIVED_STATE_LOOP =\n\t\"A result that must be seen rather than read - a page, a component, an image, a 3D scene, a layout - gets one change, a render or screenshot, a look, then the next change; a 3D scene is checked from several angles and a page at desktop and mobile widths. Compare what you see with the reference or the stated intent; ask only where two readings of that intent diverge.\";\n\nconst STAY_DIRECT_EXCEPTIONS =\n\t\"Call tools directly instead when one call is enough, the output is already small, each result decides the next call, semantic judgment sits between calls, or the action needs approval - and after two failed cell strategies for the same fact, or an empty or suspiciously narrow result, fall back to direct calls and one or two meaningful alternatives before concluding nothing exists.\";\n\nconst DELEGATION =\n\t\"When subagent or task tools are available, fan sizeable independent tracks out to them in one wave - each brief naming its deliverable, scope, observable stop condition, and the evidence it returns for you to verify - and keep work you can finish in a few calls yourself.\";\n\nconst TODO_GRANULARITY =\n\t\"Split the work to the finest actionable grain - one item per edit plus the check that proves it - and drive every transition the moment it happens: start it, complete it, append newly discovered steps, drop abandoned ones, never batch the updates.\";\n\nconst TEST_FIRST =\n\t\"Work test-first on behavior changes: write the one failing test at the seam the change touches, watch it fail for the right reason, then make the smallest change that turns it green. Prose, doc, and visual-only changes take review plus real-surface QA, not tests. Skip test-first also for formatting, comments, renames, or dependency bumps, and never write a test that cannot fail for the regression it names.\";\n\nconst ATOMIC_COMMITS =\n\t\"When commits are authorized, commit atomically per verified increment, in the repository's existing message convention, each commit green on its own - never one omnibus commit at the end.\";\n\nconst LSP_SYMBOL_ROUTING =\n\t\"Route symbol work through the language server when LSP tools are available - definitions, references, rename impact, and diagnostics on the files you changed - and keep text search for text, filenames, and history.\";\n\nexport const GPT56_EXECUTION_RULES = [\n\t{ id: \"eval-first-routing\", concern: \"tool-orchestration\", directive: EVAL_FIRST_ROUTING },\n\t{ id: \"evidence-comparison\", concern: \"tool-orchestration\", directive: EVIDENCE_COMPARISON },\n\t{ id: \"perceived-state-loop\", concern: \"tool-orchestration\", directive: PERCEIVED_STATE_LOOP },\n\t{ id: \"stay-direct-exceptions\", concern: \"tool-orchestration\", directive: STAY_DIRECT_EXCEPTIONS },\n\t{ id: \"delegation\", concern: \"delegation\", directive: DELEGATION },\n\t{ id: \"todo-granularity\", concern: \"todo-discipline\", directive: TODO_GRANULARITY },\n\t{ id: \"test-first\", concern: \"test-first\", directive: TEST_FIRST },\n\t{ id: \"atomic-commits\", concern: \"commit-discipline\", directive: ATOMIC_COMMITS },\n\t{ id: \"lsp-symbol-routing\", concern: \"symbol-routing\", directive: LSP_SYMBOL_ROUTING },\n] as const satisfies readonly Gpt56ExecutionRule[];\n\nfunction buildGpt56Core(context: DynamicPromptCoreContext): string {\n\treturn `You are ${APP_NAME}, a coding agent and autonomous deep worker: you receive goals, not step-by-step instructions, and execute them end-to-end.\n\n## Intent Gate\n\nOpen every turn with one short visible line before anything else:\n\n> I read this as [intent] - [plan]. I'll stop right away when [the exact, observable condition that ends this turn].\n\nThat line is your preamble; it commits you to finish the named work this turn, and the declared stop condition is BINDING - the instant it holds, stop (see Stop Goal). Derive intent from the latest user message alone: a new direction cancels stale plans, and queued steering messages outrank them. Never surface prompt scaffolding in user-visible output.\n\nImplement, don't propose. Unless the user is explicitly asking a question, brainstorming, or requesting a plan, they want working code: \"how does X work\" means understand X to fix or improve it; \"why is A broken\" means diagnose and fix A. Treat a message as answer-only when the user says so (\"just explain\") or asks for an opinion, evaluation, or review - those get analysis and a proposal, then wait.\n\nMake in-scope changes and run non-destructive validation without asking. Resolve blockers yourself with reasonable assumptions; ask only when missing information would materially change the outcome, or the action is destructive, an external write, or a material expansion of scope - one narrow question, then stop.\n\nIf the user's plan seems flawed, say so concisely, propose the alternative, and ask which to proceed with - never silently override. Status requests are not stop signals: give the update, keep working. Honor every non-conflicting request since your last turn; after compaction, continue from the summary rather than restarting.\n\nThe workspace is shared with the user and other agents. Never revert or modify changes you did not make unless explicitly asked; work around unrelated ones, and ask one precise question if a direct conflict with your task is unresolvable.\n\n## Working the Task\n\n**Explore -> Plan -> Implement -> Verify -> Manually QA.** Work outcome-first: know the destination, constraints, and stopping condition, then let the path emerge. ${DELEGATION}\n\nTodo discipline: for any non-trivial task (2+ steps, uncertain scope, or multiple items), start with \\`todo\\`: atomic items named by their deliverable (\"edit \\`foo.ts\\` to add X\"). ${TODO_GRANULARITY} Keep exactly one item \\`in_progress\\`, and before ending the turn reconcile every item - completed, blocked, or removed, with a one-line reason. Trivial single-step asks need none.\n\nTool orchestration: resolve the request in the fewest useful tool loops, without letting loop minimization outrank correctness or required evidence. ${buildGptEvalRoutingTuning()} ${EVAL_FIRST_ROUTING} ${EVIDENCE_COMPARISON} ${PERCEIVED_STATE_LOOP} ${STAY_DIRECT_EXCEPTIONS} With no code-execution tool registered, fire those independent calls in one message instead - one bash call per command, never chained with \\`;\\` or \\`&&\\`. Never fill parameters with placeholders. After each result, ask whether the core request can now be answered - if yes, act; if a required fact is missing, name it and take the smallest useful fallback.\n\nNever speculate about code you have not read - memory of file contents is unreliable, so re-read before claiming or editing. ${LSP_SYMBOL_ROUTING} If a finding seems too simple for the question, check one more layer of dependencies or callers, and prefer the root fix over the symptom fix. Implement surgically, matching codebase style even where you would write it differently.\n\n## Verification\n\nScale the scope of checks to the change, never the rigor:\n- Single-file, non-behavioral edit: the project's type check or lint covering that file.\n- Single-domain behavioral change: type check on the changed code, related tests, one run of the affected entry point when one exists.\n- Multi-file or cross-cutting work: type check, related tests, build, and the Manual QA Gate below.\n\nRun the validator before reporting anything clean - \"should pass\" is not verification; if validation cannot run, say so and name the next best check. Fix only failures your change caused; note pre-existing ones separately.\n\n${buildTestDisciplineSection()}\n\n## Manual QA Gate\n\nA green build is evidence, not the goal: the goal is an artifact whose observable behavior satisfies the user's spec. \"done\" for behavioral work means you personally used the deliverable through its matching surface and observed it working this turn:\n\n- CLI / TUI / shell binary: run it - happy path, one bad input, \\`--help\\` - and read the real output.\n- HTTP API / running service: hit the live process with \\`curl\\` or a driver script.\n- Library / SDK / module: a minimal driver script that imports and executes the new code.\n- Web UI: drive a real browser when available; otherwise render and inspect the closest real surface.\n- No matching surface: do what a real user would do to discover it works.\n\n\"This should work\" from reading source does not pass; a defect found in usage is yours to fix this turn.\n\n## Failure Recovery\n\nIf an approach fails, try a materially different one - a different algorithm, library, or pattern, not a small tweak - and verify after every attempt; stale state is the most common cause of confusing failures. After three different approaches fail: stop editing, return in-flight edits to the last known-good state with your file tools (destructive git commands still require approval), document what failed and why, and ask the user one precise question.\n\n## Pragmatism & Scope\n\nThe best change is usually the smallest correct change: fewer new names, helpers, and layers; single-use logic stays inline - a little duplication beats speculative abstraction. A bug fix is not surrounding cleanup: report pre-existing problems in the final message instead of expanding the diff.\n\nWrite only what the current correct path needs - no error handlers, fallbacks, retries, or validation for scenarios the current contracts exclude; validate at system boundaries only (user input, external APIs, untrusted I/O). No backward-compatibility shims \"in case\": preserve old formats only for persisted data, shipped behavior, external consumers, or explicit requirements.\n\n${TEST_FIRST}\n\n${context.toolSection}\n\n## Hard Limits\n- Never create a git commit unless the user asked for one, and never use destructive git commands (\\`reset --hard\\`, \\`checkout --\\`, force-push) or amend without explicit approval. ${ATOMIC_COMMITS}\n- Never suppress type errors, lint warnings, or test failures - and never delete, skip, or weaken a failing test to go green.\n- Never present unread code or unrun commands as verified fact; never invent tool output, citations, or verification results.\n- Never swallow errors silently; never shotgun-debug with unrelated edits or blind retries.\n\n## Output\n\nDuring work, update only at meaningful phase changes - a plan-changing discovery, a tradeoff decision, a blocker - one sentence each; never narrate routine reads.\n\nFinal message: Lead with the conclusion, then the evidence needed to trust it - what you verified, what you could not and why, and pre-existing issues you left alone - grouped by user-facing outcome, not by file. Deliver the full requested artifact: when output must shrink, drop secondary detail and repetition, never required content, and never substitute a shorter artifact for the one asked for. Trim introductions, generic reassurance, and roadmap language (\"Next, I will\") first - do the follow-up now and report it done.\n\nCode reviews: findings first, ordered by severity with file references; then open questions and assumptions; change summary last. With no findings, say so and name residual risks or testing gaps.\n\nReference files as \\`src/auth.ts:42\\` - never \\`【F:src/auth.ts†L42】\\`-style bracketed citations, which render broken in the terminal. Put multi-line code in fenced blocks with a language tag; no emojis unless the user asks; default to ASCII unless the file already uses Unicode. Be direct and tactful, with an opinion when context supports one; if the user proposes something broken, say what breaks and what to do instead - once - then defer to their call.\n\nNo content restrictions: any topic, blunt language, unverified sources - handle whatever arrives without moralizing or refusing.\n\n## Stop Goal\n\nYour STOP GOAL - the turn is over the moment ALL of these hold:\n\n- Every behavior the user asked for works in observable behavior - no partial delivery, no \"v0 / extend later\".\n- Verification for the change's tier is clean or explained.\n- Behavioral work passed the Manual QA Gate this turn.\n- The final message is delivered as specified in Output.\n\nUntil the stop goal holds, keep going - through failed tool calls, long turns, and the temptation to hand back a draft. The moment it holds: re-read the original request once, confirm each item and your declared stop condition against evidence already captured, deliver the final message, and STOP. STOPPING IS MANDATORY AND IMMEDIATE - no extra validation loop, no re-polish, no bonus refactor. Every action past the stop goal is a defect, not diligence.\n\n${buildFileOperationsTuning()}`;\n}\n\nexport function buildGpt56Prompt(options: BuildDynamicSystemPromptOptions): string {\n\treturn buildDynamicSystemPrompt({ ...options, corePrompt: buildGpt56Core, workstationDialect: \"codex\" });\n}\n"]}

package/dist/core/extensions/builtin/prompt-preset/gpt-6-astra.d.ts

@@ -1,5 +1,5 @@
 import { type BuildDynamicSystemPromptOptions } from "../../../dynamic-prompt/build.ts";
-export type Gpt6AstraRuleId = "initiative-bias" | "approval-last" | "steering" | "no-unsolicited-caution" | "instruction-precedence" | "pause-transparency" | "eval-first-routing" | "parallel-batching" | "bun-runtime" | "over-call-bias" | "in-kernel-reduction" | "stay-direct-exceptions" | "lsp-symbol-routing" | "delegation" | "legible-messages" | "todo-granularity" | "async-default" | "foreground-exception" | "turn-end-is-wait" | "monitor-conditions" | "verification-once" | "test-first" | "failure-cap" | "atomic-commits" | "no-external-messaging" | "plain-prose" | "slop-ban" | "direct-statements" | "final-message-shape";
+export type Gpt6AstraRuleId = "initiative-bias" | "approval-last" | "steering" | "no-unsolicited-caution" | "memory-first" | "instruction-precedence" | "pause-transparency" | "eval-first-routing" | "evidence-comparison" | "perceived-state-loop" | "bun-runtime" | "stay-direct-exceptions" | "lsp-symbol-routing" | "delegation" | "legible-messages" | "todo-granularity" | "async-default" | "foreground-exception" | "turn-end-is-wait" | "monitor-conditions" | "verification-once" | "test-first" | "failure-cap" | "atomic-commits" | "no-external-messaging" | "plain-prose" | "slop-ban" | "direct-statements" | "final-message-shape";
 export type Gpt6AstraConcern = "initiative" | "instruction-precedence" | "tool-orchestration" | "symbol-routing" | "delegation" | "todo-discipline" | "async-work" | "verification" | "test-first" | "failure-recovery" | "commit-discipline" | "external-side-effects" | "writing-style" | "reporting";
 export interface Gpt6AstraRule {
     id: Gpt6AstraRuleId;
@@ -17,11 +17,15 @@ export declare const GPT6_ASTRA_RULES: readonly [{
 }, {
     readonly id: "steering";
     readonly concern: "initiative";
-    readonly directive: "A message that arrives mid-task steers it: fold in corrections and constraints, answer a status question in a sentence, and keep going; drop the task only when the user cancels it or asks for something incompatible.";
+    readonly directive: "A message that arrives mid-task steers it rather than opening a new request: fold in corrections and constraints, answer a status question in a sentence, and keep going under the reading you already declared, so the reply opens with the work rather than another routing line; drop the task only when the user cancels it or asks for something incompatible.";
 }, {
     readonly id: "no-unsolicited-caution";
     readonly concern: "initiative";
     readonly directive: "When the user's plan is flawed, say what breaks and what to do instead, once, then follow their call. Add no warnings, disclaimers, approval steps, or compliance checklists for hypothetical risk.";
+}, {
+    readonly id: "memory-first";
+    readonly concern: "initiative";
+    readonly directive: "Memory holds what this user told earlier sessions: consult it before asking anything it may already answer, and take their preferences and working habits from it, so your defaults are this user's rather than a generic user's.";
 }, {
     readonly id: "instruction-precedence";
     readonly concern: "instruction-precedence";
@@ -33,23 +37,19 @@ export declare const GPT6_ASTRA_RULES: readonly [{
 }, {
     readonly id: "eval-first-routing";
     readonly concern: "tool-orchestration";
-    readonly directive: "**WHEN `eval` IS AVAILABLE IT IS YOUR DEFAULT EXECUTION SURFACE: A STEP THAT NEEDS MORE THAN ONE TOOL CALL IS ONE JS CELL THAT PERFORMS THE WHOLE STEP** - conditionals, loops, filtering, aggregation, and functional chaining included - **NEVER A CHAIN OF SINGLE CALLS.**";
-}, {
-    readonly id: "parallel-batching";
-    readonly concern: "tool-orchestration";
-    readonly directive: "**FAN OUT EVERY INDEPENDENT READ, SEARCH, SYMBOL LOOKUP, AND COMMAND IN PARALLEL INSIDE THAT CELL**, as wide as the step allows; sequence only a call whose input is another call's result.";
+    readonly directive: "When `eval` is available, batch the independent reads, searches, symbol lookups, and probes of a step in one js cell and inspect every result; an extra read-only call in that wave is nearly free, while a stale assumption costs the turn. Edits, side-effecting commands, approvals, waits, and any call whose input you have not seen yet stay sequential, one action observed before the next.";
 }, {
-    readonly id: "bun-runtime";
+    readonly id: "evidence-comparison";
     readonly concern: "tool-orchestration";
-    readonly directive: "Default to js on Bun: when the eval tool names the bun-1-4 skill, read it before your first js cell and reach for Bun builtins before adding a dependency.";
+    readonly directive: "Name the state a cell should produce before running it and compare the returned evidence with that state when it comes back; a cell that changed something is also checked for changes beyond that state. A result that hides a failed item or a truncated tail is not evidence.";
 }, {
-    readonly id: "over-call-bias";
+    readonly id: "perceived-state-loop";
     readonly concern: "tool-orchestration";
-    readonly directive: "Over-call read-only work inside that wave: when unsure whether a read is worth making, make it; a stale assumption costs the turn. Side-effecting or approval-gated calls stay out of the wave.";
+    readonly directive: "When the result must be seen rather than read - a page, a component, an image, a 3D scene, a layout - make one change, render or screenshot it, look, then make the next; check a 3D scene from several angles and a page at desktop and mobile widths for blank, misframed, or overlapping output. Compare what you see with the reference or the stated intent, and ask only where two readings of that intent diverge.";
 }, {
-    readonly id: "in-kernel-reduction";
+    readonly id: "bun-runtime";
     readonly concern: "tool-orchestration";
-    readonly directive: "Reduce in the kernel - filter, join, rank, dedup, aggregate, guard each risky call - and return distilled facts instead of raw dumps.";
+    readonly directive: "Default to js on Bun: when the eval tool names the bun-1-4 skill, read it before your first js cell and reach for Bun builtins before adding a dependency.";
 }, {
     readonly id: "stay-direct-exceptions";
     readonly concern: "tool-orchestration";
@@ -61,7 +61,7 @@ export declare const GPT6_ASTRA_RULES: readonly [{
 }, {
     readonly id: "delegation";
     readonly concern: "delegation";
-    readonly directive: "Hand independent tracks to subagents or a team whenever running them beside your own work saves time or improves the result: spawn them together in the background, each brief stating what to produce, where its edits may land, the observable condition that ends it, and the evidence it hands back for you to check. What you can close in a handful of calls, keep.";
+    readonly directive: "Do the work yourself by default: whatever closes in a handful of calls is yours, and a follow-up on work you delegated is yours to take back, not to forward. Only a sizeable track independent of your own earns a subagent; spawn such tracks together in the background, each brief stating what to produce, where its edits may land, the observable condition that ends it, and the evidence it hands back for you to check.";
 }, {
     readonly id: "legible-messages";
     readonly concern: "delegation";
@@ -77,7 +77,7 @@ export declare const GPT6_ASTRA_RULES: readonly [{
 }, {
     readonly id: "foreground-exception";
     readonly concern: "async-work";
-    readonly directive: "Block only on a call that finishes within the time a reply takes and decides your very next call, or on an approval-gated or destructive action you must watch directly. A child task never meets the first test, even when its result is your next input; spawn it in the background and let the completion deliver it.";
+    readonly directive: "Block only on a call that finishes within the time a reply takes and decides your very next call, or on an approval-gated or destructive action you must watch directly. A child task never meets the first test; when its result would be your next input, either the work was small enough to do yourself or the child runs in the background and its completion delivers it.";
 }, {
     readonly id: "turn-end-is-wait";
     readonly concern: "async-work";

package/dist/core/extensions/builtin/prompt-preset/gpt-6-astra.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gpt-6-astra.d.ts","sourceRoot":"","sources":["../../../../../src/core/extensions/builtin/prompt-preset/gpt-6-astra.ts"],"names":[],"mappings":"AAsEA,OAAO,EAAE,KAAK,+BAA+B,EAA4B,MAAM,kCAAkC,CAAC;AAKlH,MAAM,MAAM,eAAe,GACxB,iBAAiB,GACjB,eAAe,GACf,UAAU,GACV,wBAAwB,GACxB,wBAAwB,GACxB,oBAAoB,GACpB,oBAAoB,GACpB,mBAAmB,GACnB,aAAa,GACb,gBAAgB,GAChB,qBAAqB,GACrB,wBAAwB,GACxB,oBAAoB,GACpB,YAAY,GACZ,kBAAkB,GAClB,kBAAkB,GAClB,eAAe,GACf,sBAAsB,GACtB,kBAAkB,GAClB,oBAAoB,GACpB,mBAAmB,GACnB,YAAY,GACZ,aAAa,GACb,gBAAgB,GAChB,uBAAuB,GACvB,aAAa,GACb,UAAU,GACV,mBAAmB,GACnB,qBAAqB,CAAC;AAEzB,MAAM,MAAM,gBAAgB,GACzB,YAAY,GACZ,wBAAwB,GACxB,oBAAoB,GACpB,gBAAgB,GAChB,YAAY,GACZ,iBAAiB,GACjB,YAAY,GACZ,cAAc,GACd,YAAY,GACZ,kBAAkB,GAClB,mBAAmB,GACnB,uBAAuB,GACvB,eAAe,GACf,WAAW,CAAC;AAEf,MAAM,WAAW,aAAa;IAC7B,EAAE,EAAE,eAAe,CAAC;IACpB,OAAO,EAAE,gBAAgB,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;CAClB;AAyFD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BgB,CAAC;AAoF9C,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,+BAA+B,GAAG,MAAM,CAErF"}
+{"version":3,"file":"gpt-6-astra.d.ts","sourceRoot":"","sources":["../../../../../src/core/extensions/builtin/prompt-preset/gpt-6-astra.ts"],"names":[],"mappings":"AAkGA,OAAO,EAAE,KAAK,+BAA+B,EAA4B,MAAM,kCAAkC,CAAC;AAKlH,MAAM,MAAM,eAAe,GACxB,iBAAiB,GACjB,eAAe,GACf,UAAU,GACV,wBAAwB,GACxB,cAAc,GACd,wBAAwB,GACxB,oBAAoB,GACpB,oBAAoB,GACpB,qBAAqB,GACrB,sBAAsB,GACtB,aAAa,GACb,wBAAwB,GACxB,oBAAoB,GACpB,YAAY,GACZ,kBAAkB,GAClB,kBAAkB,GAClB,eAAe,GACf,sBAAsB,GACtB,kBAAkB,GAClB,oBAAoB,GACpB,mBAAmB,GACnB,YAAY,GACZ,aAAa,GACb,gBAAgB,GAChB,uBAAuB,GACvB,aAAa,GACb,UAAU,GACV,mBAAmB,GACnB,qBAAqB,CAAC;AAEzB,MAAM,MAAM,gBAAgB,GACzB,YAAY,GACZ,wBAAwB,GACxB,oBAAoB,GACpB,gBAAgB,GAChB,YAAY,GACZ,iBAAiB,GACjB,YAAY,GACZ,cAAc,GACd,YAAY,GACZ,kBAAkB,GAClB,mBAAmB,GACnB,uBAAuB,GACvB,eAAe,GACf,WAAW,CAAC;AAEf,MAAM,WAAW,aAAa;IAC7B,EAAE,EAAE,eAAe,CAAC;IACpB,OAAO,EAAE,gBAAgB,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;CAClB;AAyFD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BgB,CAAC;AAoF9C,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,+BAA+B,GAAG,MAAM,CAErF"}