@chinhae/atw-cli 0.5.0 → 0.7.0

package/dist/templates/common/commands/finish-work.md

@@ -51,10 +51,19 @@ Then route:
 {{PYTHON_CMD}} ./.atw/scripts/task.py archive <task-name>
 ```
 
-At minimum: the current active task (if any). Plus any extra tasks the user confirmed in Step 1. Each archive produces a `chore(task): archive ...` commit via the script's auto-commit.
+At minimum: the current active task (if any). Plus any extra tasks the user confirmed in Step 1. Each archive produces a `chore(task): archive ...` commit via the script's auto-commit — unless the task's `standing-orders.md` has an order on commit messages: then pass `--no-commit` and commit the move yourself as the order says (`.atw/workflow.md` 3.2).
 
 If there is no active task and the user did not confirm any cleanup archives, skip this step.
 
+Right after a `task.py archive` that moved a task under `archive/`, add one sentence that the user can look back over this conversation for what to improve (复盘), with the input for their current tool only — the one line below that names that tool:
+
+- Claude Code: `/atw-reflect`
+- Codex: `$atw-reflect`
+- pi: `/skill:atw-reflect`
+- omp: `/skill:atw-reflect`
+
+You never start it yourself. Once per task: an archive moves a task only once, so this comes once per task; several tasks archived in this step share one sentence. Say it once in the reply that reports the archive, in the part about the archive, not again where the reply wraps up.
+
 ## Step 4: Record session journal
 
 ```bash

package/dist/templates/common/commands/start.md

@@ -52,7 +52,9 @@ Load the step detail before acting on it:
 
 `{{CMD_REF:continue}}` carries the same six stages with their artifact checks and stop points — use it when you need more than the step number.
 
-**No active task** → classify first. For simple conversation / small task, ask only whether this turn should create an ATW task. For complex work, ask whether you may create an ATW task and enter `discover` — that ask is **stop ①**, and task creation is step **1.0**. If the user says no, skip ATW for this session.
+**No active task, and the request is about a task that already exists** — the user names it, or asks to continue or accept and only one open task fits (Step 1 lists them) → make it this session's task first; do not ask whether to create a new one. Use `task.py resume <task>` at any stage, `implement` and `accept` included: it only bookmarks the task for this session and changes no file. `task.py start` is only for step 1.5, where a task leaves `slice` (or `specify`, when the work was not sliced) for `implement`; do not run it to pick up a task. Then follow its stage as above: `implement` → **2.1**, `accept` → **3.1**. Several open tasks fit and nothing tells which: ask which one.
+
+**Any other request** → classify first. For simple conversation / small task, ask whether this turn should create an ATW task. In that ask, say what each answer means: without a task there is no requirements document (`prd.md`) and no formal acceptance (each requirement checked with evidence, the user signs off); a task adds writing the requirements, the user confirming the spec, implementing against it, and that acceptance before archiving. For complex work, ask whether you may create an ATW task and enter `discover` — that ask is **stop ①**, and task creation is step **1.0**. If the user says no, skip ATW for this session.
 
 ---
 

package/dist/templates/common/skills/update-spec.md

@@ -98,7 +98,30 @@ Answer these questions:
 2. **Why is it important?** (What problem does it prevent?)
 3. **Where does it belong?** (Which spec file?)
 
-### Step 2: Classify the Update Type
+### Step 2: Ask Whether It Can Be Enforced
+
+Before writing a single line of docs, fix the lesson at the highest level that works. Assume every contributor is an agent that sees only the files it opened, copies the nearest example, and takes the shortest path that compiles. Design the repo so a change that looks right from one file is right for the whole repo.
+
+1. **Eliminate it with architecture.** Give each piece of state one owner and each task one supported way. Hide internals so the wrong import fails. Replace hand-synced lists with one source of truth. Delete old ways and dead code an agent would copy.
+2. **Enforce it with types so the bad state can't be written.** If bad code still compiles, add a lint or CI check whose error names the file, type, or function to use instead. If the pattern is already common, fail only when a change adds more.
+3. **Test the behavior.** Fix or delete any test that still passes when the behavior it checks breaks, or that fails when only the internals change.
+4. **Write docs last, only for judgment calls.** Nothing fails when an agent skips them.
+
+Tell the user the level you picked and why a higher level didn't work.
+
+After a fix at levels 1–3, the docs entry is only a pointer — make the docs entry point at it: the rule in one sentence plus "enforced by `<test file or checker>`". Docs that only repeat what the test already enforces are noise. Steps 3–6 below apply when the rule is written as docs (level 4).
+
+**When code may not change here** — called during the acceptance check, or anywhere else that is read-only — do not make a level 1–3 fix in place. Instead write it as a new ticket the way the project's tracker doc says (`docs/agents/issue-tracker.md`), and write only the rule's row and its docs now: "Docs only" under "Enforced by" and the ticket under "Where", until the ticket lands.
+
+**Fix and prove.** Prove each new check fails on a real past mistake. Run the same command locally and in CI. Exceptions go on the offending line with a reason, an expiry date, and a human's approval — never your own. In an unattended run nobody can approve one: write no exception; log one decision-log row marked needs-you (`python3 .atw/scripts/decision_log.py add … --mark needs-you`) naming the line and why it needs one, and leave it for the user. Write each exception into the rule's row, in the rule table's `Expires` column, as its expiry date plus its `file:line` — several exceptions, several entries. If the project's table has no `Expires` column — tables written before it existed keep their old header, because `atw update` never touches `.atw/spec/` — add the column, with `—` in every existing row, the first time you write an exception.
+
+**Drop a rule once its mistake can't happen** — when the thing it guarded no longer exists, delete its docs and its row in the rule table. A rule fixed at architecture or types is not dropped: its row stays, pointing at what enforces it.
+
+**Find the mistake classes only when the correction repeats.** When the user says it goes this way from now on (以后都这样), or a choice of the same kind is overruled a second time, first read recent commits, reverts, review comments, agent instruction files, and comments that explain workarounds. Group the mistakes into classes. A class counts once it has happened twice. Fix the most frequent classes now, one commit each, each at the highest level that works. Otherwise skip this and fix only the lesson in front of you.
+
+**Keep the rule table** — **every rule you write gets a row in the rule table** at the top of the layer's `quality-guidelines.md`: the rule, what enforces it, where that lives, which task or bug produced it, and the expiry date of each exception to it. When the user corrects you, fix the mistake and add the rule. If the rule was already there and nothing enforces it, that's a repeat, so fix it at the highest level in the same change. A row whose "Enforced by" reads "Docs only" is the signal that the next time this rule is broken you upgrade it to a test or lint instead of rewording the docs — it is not the end point.
+
+### Step 3: Classify the Update Type
 
 | Type | Description | Action |
 |------|-------------|--------|
@@ -110,7 +133,7 @@ Answer these questions:
 | **Convention** | Agreed-upon standard | Add to relevant section |
 | **Gotcha** | Non-obvious behavior | Add warning callout |
 
-### Step 3: Read the Target Code-Spec
+### Step 4: Read the Target Code-Spec
 
 Before editing, read the current code-spec to:
 - Understand existing structure
@@ -121,7 +144,7 @@ Before editing, read the current code-spec to:
 cat .atw/spec/<category>/<file>.md
 ```
 
-### Step 4: Make the Update
+### Step 5: Make the Update
 
 Follow these principles:
 
@@ -131,7 +154,7 @@ Follow these principles:
 4. **Show Code**: Add code snippets for key patterns
 5. **Keep it Short**: One concept per section
 
-### Step 5: Update the Index (if needed)
+### Step 6: Update the Index (if needed)
 
 If you added a new section or the code-spec status changed, update the category's `index.md`.
 
@@ -321,6 +344,7 @@ Before finishing your code-spec update:
 - [ ] Did you include Good/Base/Bad cases?
 - [ ] Did you include required tests with assertion points?
 - [ ] Is it in the right code-spec file?
+- [ ] Did you add a row to the rule table (and is "Docs only" really the only option)?
 - [ ] Does it duplicate existing content?
 - [ ] Would a new team member understand it?
 
@@ -350,3 +374,15 @@ The goal is **institutional memory**:
 - What one person learns, everyone benefits from
 - What AI learns in one session, persists to future sessions
 - Mistakes become documented guardrails
+
+---
+
+## Rationalizations specific to this skill
+
+Same shape as the general table in `.atw/workflow.md`; these are the excuses that only show up while capturing lessons.
+
+| Rationalization | Reality |
+|---|---|
+| Writing it into the docs is capturing it | What a test or lint can enforce becomes a test or lint first; the docs record only what cannot be written into code |
+| This rule is too obvious to record | Obvious rules only arrive here after they have been broken |
+| Note it down now, add the test later | "Docs only" in the rule table is the signal for the next upgrade, not the end point |

package/dist/templates/copilot/hooks/session-start.py

@@ -236,8 +236,8 @@ def _get_task_status(atw_dir: Path, hook_input: dict, general: bool = False) ->
             )
         return (
             "Status: NO ACTIVE TASK\n"
-            "Next: Classify the current turn and ask for task-creation consent "
-            "before creating any ATW task."
+            "Next: If the request is about a task that already exists — the user names it, or asks to continue or accept and only one open task fits — make it this session's task first, as the no-task breadcrumb says; do not ask whether to create a new one. "
+            "Otherwise classify the current turn and ask for task-creation consent before creating any ATW task."
         )
 
     task_ref = active.task_path

package/dist/templates/dsh/DSH.md

@@ -76,9 +76,9 @@ In dsh:
 
 ## File map
 
-- `.agents/skills/` — the six skills of `general` mode: `atw-interview`,
+- `.agents/skills/` — the seven skills of `general` mode: `atw-interview`,
   `atw-research`, `atw-session-insight`, `atw-noob-mode`, `atw-askme`,
-  `atw-handoff`.
+  `atw-handoff`, `atw-what-happened`.
 - `.dsh/skills/` — the dsh-private entry skill `atw-start`.
 - `.atw/` — tasks, the conventions file (`.atw/spec/conventions.md`),
   workspace memory, and the shared scripts the skills invoke

package/dist/templates/markdown/spec/backend/quality-guidelines.md.txt

@@ -4,6 +4,16 @@
 
 ---
 
+## Rule Table
+
+Every rule in this file has a row here: the rule in one sentence, what enforces it (architecture / types / lint / test / script / docs only), where that enforcement lives (test file or checker name), the task or bug that produced it, and the expiry date of each exception to this rule with its `file:line` (`—` when there is none). Add a row whenever you write a rule. "Docs only" means nothing in code catches a violation yet — the next time that rule is broken, upgrade it to a test, lint or script instead of rewording the docs. Delete the row once the rule can no longer be broken. The `_Example:_` row below is a placeholder, not a rule — replace it with your first real rule.
+
+| Rule | Enforced by | Where | Source | Expires |
+|------|-------------|-------|--------|---------|
+| _Example: no `console.log` left in committed code_ | lint | `eslint no-console` | _task or bug id_ | `—` |
+
+---
+
 ## Overview
 
 <!--

package/dist/templates/markdown/spec/frontend/quality-guidelines.md.txt

@@ -4,6 +4,16 @@
 
 ---
 
+## Rule Table
+
+Every rule in this file has a row here: the rule in one sentence, what enforces it (architecture / types / lint / test / script / docs only), where that enforcement lives (test file or checker name), the task or bug that produced it, and the expiry date of each exception to this rule with its `file:line` (`—` when there is none). Add a row whenever you write a rule. "Docs only" means nothing in code catches a violation yet — the next time that rule is broken, upgrade it to a test, lint or script instead of rewording the docs. Delete the row once the rule can no longer be broken. The `_Example:_` row below is a placeholder, not a rule — replace it with your first real rule.
+
+| Rule | Enforced by | Where | Source | Expires |
+|------|-------------|-------|--------|---------|
+| _Example: no `console.log` left in committed code_ | lint | `eslint no-console` | _task or bug id_ | `—` |
+
+---
+
 ## Overview
 
 <!--

package/dist/templates/omp/config.yml

@@ -0,0 +1,15 @@
+# ATW: omp otherwise leaves delegating to sub-agents to the model's own policy,
+# and under some models it then refuses /skill:atw-implement-all's one
+# implementer sub-agent per ticket. With this, every omp session in this
+# project leans toward handing work to sub-agents; delete these lines to go
+# back to omp's default.
+task:
+  eager: preferred # set by ATW
+
+# ATW: omp otherwise cuts every line of a command's output and of a file it
+# reads at 768 bytes and drops the rest; ATW's workflow and skills have longer
+# lines, and the model then misses the rules at their ends. With this, omp
+# shows every line whole in this project; delete these lines to go back to
+# omp's default.
+tools:
+  outputMaxColumns: 0 # set by ATW

package/dist/templates/omp/extensions/atw/index.ts.txt

@@ -40,7 +40,46 @@ function buildContextKey(platformName: string, kind: string, value: string): str
    return safeValue ? `${platformName}_${safeValue}` : `${platformName}_${hashValue(value)}`;
 }
 
-function deriveContextKey(ctx?: { sessionManager?: { getSessionId?: () => string | undefined; getSessionFile?: () => string | undefined } }): string | null {
+type SessionCtx = { sessionManager?: { getSessionId?: () => string | undefined; getSessionFile?: () => string | undefined } };
+
+// omp 子代理的会话文件放在父会话的附件目录里（<父>.jsonl → <父>/<名字>.jsonl），
+// omp 自己找根会话也按这个规矩往上走（最多 8 层）。同进程的子代理不设
+// PI_BLOCKED_AGENT，只能这样认。另起的分支会话与父会话同级，不算子代理。
+function outermostSessionFile(ctx?: SessionCtx): string | null {
+   const sessionFile = ctx?.sessionManager?.getSessionFile?.();
+   if (!sessionFile) return null;
+   let current = resolve(sessionFile);
+   let root: string | null = null;
+   for (let depth = 0; depth < 8; depth++) {
+      const parentFile = `${dirname(current)}.jsonl`;
+      if (!existsSync(parentFile)) break;
+      current = parentFile;
+      root = parentFile;
+   }
+   return root;
+}
+
+function sessionHeaderId(sessionFile: string): string | null {
+   const prefix = readFilePrefix(sessionFile, 16 * 1024);
+   if (!prefix) return null;
+   for (const line of prefix.data.toString("utf-8").split("\n")) {
+      try {
+         const entry = JSON.parse(line) as { type?: unknown; id?: unknown };
+         if (entry.type === "session" && typeof entry.id === "string" && entry.id) return entry.id;
+      } catch {
+         // 不是完整的一行 JSON（读到前缀末尾被截断），接着看下一行
+      }
+   }
+   return null;
+}
+
+// 子代理自己的编号没绑任务，沿用最外层会话的编号
+function deriveContextKey(ctx?: SessionCtx): string | null {
+   const outermostFile = outermostSessionFile(ctx);
+   const outermostSessionId = outermostFile ? sessionHeaderId(outermostFile) : null;
+   if (outermostSessionId) {
+      return buildContextKey("omp", "session", outermostSessionId);
+   }
    const sessionId = ctx?.sessionManager?.getSessionId?.();
    if (sessionId) {
       return buildContextKey("omp", "session", sessionId);
@@ -779,6 +818,37 @@ function shouldSkipWorkflowState(
 // single event cascade (input, before_agent_start, and context fire closely)
 // ---------------------------------------------------------------------------
 
+// Mirrors DECISION_LOG_REMINDER / has_decision_log() in the shared per-turn
+// Python hook: same sentence, implement or accept only.
+const DECISION_LOG_REMINDER =
+   "This task has a decision log: keep recording it at key points with `python3 ./.atw/scripts/decision_log.py`; in this conversation, the start row (`decision_log.py start`) goes in just before the first row you log — `add` and the other writing commands write it first when it is missing, so a conversation with nothing to log writes none; read the last rows they print, and when another conversation wrote in between they write only the start row and stop: read it, then run the same command again.";
+// Mirrors DECISION_LOG_ARCHIVE_REMINDER in the shared per-turn Python hook:
+// same sentence, accept only (with a log), placed before DECISION_LOG_REMINDER.
+const DECISION_LOG_ARCHIVE_REMINDER =
+   "This task has a decision log: once accepted, after the acceptance row and before `task.py archive`, log one row for the archive (`decision_log.py add`); it goes into the archive commit with the task.";
+// Mirrors DECISION_LOG_REPORT_REMINDER in the shared per-turn Python hook:
+// same sentence, implement or accept (with a log), just before DECISION_LOG_REMINDER.
+const DECISION_LOG_REPORT_REMINDER =
+   "This task has a decision log: when the user asks how things stand or for a report (汇报一下, 现在什么情况, what's the status, report), rebuild it from the task directory in four blocks — `python3 ./.atw/scripts/decision_log.py pending --report` prints the draft; post it in plain words, keep the plain-words lines it carries with noob mode on, and fill in what it marks. This is the task's report, not `atw-what-happened`: that skill only the user starts, and it tells what changed in this chat since their last message.";
+
+// Mirrors DECISION_LOG_NO_TASK_REPORT_REMINDER / any_task_has_decision_log() in
+// the shared per-turn Python hook: same sentence, no current task only.
+const DECISION_LOG_NO_TASK_REPORT_REMINDER =
+   "No task is current, but some task under `.atw/tasks/` has a decision log: when the user asks how things stand or for a report (汇报一下, 现在什么情况, what's the status, report), rebuild it from that task's directory in four blocks — list the active tasks with `python3 ./.atw/scripts/task.py list` and see which of their directories hold a `decision-log.md` (if the user named the task or said enough to tell which one, take that one; if not, only one, take it; several, ask the user which), then `python3 ./.atw/scripts/decision_log.py pending --report --task-dir <dir>` prints the draft; post it in plain words, keep the plain-words lines it carries with noob mode on, and fill in what it marks. This is the task's report, not `atw-what-happened`: that skill only the user starts, and it tells what changed in this chat since their last message.";
+
+// 只看 .atw/tasks/ 下一层、只认文件，归档里的不算；读不了当作没有，不打断这一轮
+function anyTaskHasDecisionLog(projectRoot: string): boolean {
+   const tasksDir = join(projectRoot, ".atw", "tasks");
+   try {
+      return readdirSync(tasksDir).some((name) => {
+         const p = join(tasksDir, name, "decision-log.md");
+         return existsSync(p) && statSync(p).isFile();
+      });
+   } catch {
+      return false;
+   }
+}
+
 const SESSION_OVERVIEW_TEXT =
    "ATW workflow system active. Use skills and agents as directed by the workflow state.";
 
@@ -797,9 +867,10 @@ class TurnContextCache {
       this.key = null;
    }
 
-   get(projectRoot: string, contextKey: string | null): { workflowMsg: string } {
+   // 决定日志只由主对话写：子代理的每轮提示不带日志提醒
+   get(projectRoot: string, contextKey: string | null, subAgent: boolean): { workflowMsg: string } {
       const now = Date.now();
-      const cacheKey = `${projectRoot}:${contextKey ?? ""}`;
+      const cacheKey = `${projectRoot}:${contextKey ?? ""}:${subAgent}`;
       if (
          this.key === cacheKey &&
          now - this.timestamp < TurnContextCache.TTL_MS
@@ -807,7 +878,20 @@ class TurnContextCache {
          return { workflowMsg: this.workflowMsg };
       }
 
-      const { status } = resolveActiveTaskStatus(projectRoot, contextKey);
+      const { status, taskDir } = resolveActiveTaskStatus(projectRoot, contextKey);
+      // 只认文件，与共享钩子的 is_file() 一致
+      const logPath = taskDir !== null ? join(taskDir, "decision-log.md") : null;
+      const decisionLog =
+         !subAgent &&
+         (status === "implement" || status === "accept") &&
+         logPath !== null &&
+         existsSync(logPath) &&
+         statSync(logPath).isFile();
+      const tail = decisionLog
+         ? `${status === "accept" ? `\n${DECISION_LOG_ARCHIVE_REMINDER}` : ""}\n${DECISION_LOG_REPORT_REMINDER}\n${DECISION_LOG_REMINDER}`
+         : !subAgent && status === "no_task" && anyTaskHasDecisionLog(projectRoot)
+           ? `\n${DECISION_LOG_NO_TASK_REPORT_REMINDER}`
+           : "";
 
       const workflowPath = join(projectRoot, ".atw", "workflow.md");
       let workflowMd = "";
@@ -818,11 +902,11 @@ class TurnContextCache {
          const blocks = parseWorkflowStateBlocks(workflowMd);
          const activeBlock = blocks.find((b) => b.status === status);
          if (activeBlock) {
-            workflowBody = `[workflow-state:${activeBlock.status}]\n${activeBlock.content}\n[/workflow-state:${activeBlock.status}]`;
+            workflowBody = `[workflow-state:${activeBlock.status}]\n${selectPlatformBlocks(activeBlock.content, "Oh My Pi")}${tail}\n[/workflow-state:${activeBlock.status}]`;
          }
       }
       if (!workflowBody) {
-         workflowBody = "Refer to workflow.md for current step.";
+         workflowBody = `Refer to workflow.md for current step.${tail}`;
       }
 
       // When skip keyword is present, skip workflow state injection this turn
@@ -859,6 +943,31 @@ function parseWorkflowStateBlocks(markdown: string): WorkflowStateBlock[] {
    return blocks;
 }
 
+// Mirrors select_platform_blocks() in .atw/scripts/common/workflow_phase.py:
+// keep only the `[Platform, ...]` blocks naming this platform, or every block
+// when none does; marker lines are always dropped.
+const PLATFORM_MARKER_RE = /^\[(\/?)([A-Za-z][^[\]]*)\]\s*$/;
+function selectPlatformBlocks(body: string, platform: string): string {
+   const norm = (s: string) => s.toLowerCase().replace(/[-_ ]/g, "");
+   const names = (m: RegExpMatchArray) => (m[2] ?? "").split(",").map((n) => norm(n.trim()));
+   const lines = body.split("\n");
+   const anyMatch = lines.some((l) => {
+      const m = l.match(PLATFORM_MARKER_RE);
+      return !!m && m[1] !== "/" && names(m).includes(norm(platform));
+   });
+   const out: string[] = [];
+   let keep = true;
+   for (const line of lines) {
+      const m = line.match(PLATFORM_MARKER_RE);
+      if (m) {
+         keep = m[1] === "/" || !anyMatch || names(m).includes(norm(platform));
+         continue;
+      }
+      if (keep) out.push(line);
+   }
+   return out.join("\n");
+}
+
 // ---------------------------------------------------------------------------
 // Sub-agent detection
 // ---------------------------------------------------------------------------
@@ -890,6 +999,11 @@ export default function(pi: ExtensionAPI): void {
    const turnCache = new TurnContextCache();
    const agentType = detectAgentType();
    const isSubAgent = agentType !== null;
+   // 同进程子代理（omp 18 的 task 工具）不设 PI_BLOCKED_AGENT，按会话文件认
+   const isSubAgentSession = (ctx?: SessionCtx): boolean => isSubAgent || outermostSessionFile(ctx) !== null;
+   // Same switch as the other platforms' hooks: channel sets ATW_HOOKS=0 on
+   // its helpers, which must not receive prompts written for the main AI.
+   const hooksDisabled = process.env.ATW_HOOKS === "0" || process.env.ATW_DISABLE_HOOKS === "1";
    let taskContextCache: TaskContextCache | null = null;
 
    // Tracks compaction boundaries — context handler skips scanning when no
@@ -914,12 +1028,13 @@ export default function(pi: ExtensionAPI): void {
    };
 
    pi.on("session_start", async (_event, ctx) => {
+      if (hooksDisabled) return;
       projectRoot = findProjectRoot(ctx.cwd);
       const contextKey = rememberContextKey(ctx);
 
       if (!projectRoot) return;
 
-      if (isSubAgent) {
+      if (isSubAgentSession(ctx)) {
          // Sub-agent: inject precise task context once
          const { taskDir } = resolveActiveTaskStatus(projectRoot, contextKey);
          if (taskDir) {
@@ -964,6 +1079,7 @@ export default function(pi: ExtensionAPI): void {
    });
 
    pi.on("before_agent_start", async (_event, ctx) => {
+      if (hooksDisabled) return;
       if (!projectRoot) {
          projectRoot = findProjectRoot(ctx.cwd);
       }
@@ -971,7 +1087,7 @@ export default function(pi: ExtensionAPI): void {
       const contextKey = rememberContextKey(ctx);
 
       // Persistent injection: workflow state for this turn
-      const cached = turnCache.get(projectRoot, contextKey);
+      const cached = turnCache.get(projectRoot, contextKey, isSubAgentSession(ctx));
       lastInjectionTs = Date.now();
 
       // Skip turn: inject nothing (escape hatch)
@@ -990,6 +1106,7 @@ export default function(pi: ExtensionAPI): void {
    // and post-compaction agent.continue() paths). Acts as a safety net when
    // before_agent_start's persisted message was removed by compaction.
    pi.on("context", async (event, ctx) => {
+      if (hooksDisabled) return;
       if (!projectRoot) return;
       const contextKey = rememberContextKey(ctx);
 
@@ -1020,7 +1137,7 @@ export default function(pi: ExtensionAPI): void {
 
       // Resolve the turn state before the fast path: a skip turn must still
       // run breadcrumb cleanup even when nothing else changed.
-      const cached = turnCache.get(projectRoot, contextKey);
+      const cached = turnCache.get(projectRoot, contextKey, isSubAgentSession(ctx));
       const skipping = !cached.workflowMsg;
 
       // Fast path: no task change, no compaction, not skipping — all persisted context is current.
@@ -1060,18 +1177,18 @@ export default function(pi: ExtensionAPI): void {
       };
    });
 
-   // OMP passes Bash event.input through to the tool execution parameters, so
-   // inject the session key through the shell-agnostic env field. An explicit
-   // per-call value wins over the derived key.
+   // omp 18 的 bash 工具参数没有 env，往 event.input.env 里塞的编号到不了 shell
+   // （工单 19 核实）。改成在命令前 export：编号只含 [A-Za-z0-9._-]，不用加引号；
+   // 命令里自己赋值的写在后面，照旧以它为准。调用自带 env 编号时（老版本 omp
+   // 认 env）不动。按文档返回 input，也改原对象，后面的扩展看到的是同一条命令。
    pi.on("tool_call", (event, ctx) => {
       if (event.toolName !== "bash") return;
       const contextKey = rememberContextKey(ctx);
       if (!contextKey) return;
-      const input = event.input as { env?: Record<string, string> };
-      input.env = {
-         ATW_CONTEXT_ID: contextKey,
-         ...input.env,
-      };
+      const input = event.input as { command: string; env?: Record<string, string> };
+      if (input.env?.ATW_CONTEXT_ID) return;
+      input.command = `export ATW_CONTEXT_ID=${contextKey}\n${input.command}`;
+      return { input };
    });
 
    pi.on("input", async (event, ctx) => {
@@ -1089,6 +1206,6 @@ export default function(pi: ExtensionAPI): void {
       // Record the turn's skip decision and pre-warm the cache so
       // before_agent_start and context can use it
       turnCache.beginTurn(skipThisTurn);
-      turnCache.get(projectRoot, contextKey);
+      turnCache.get(projectRoot, contextKey, isSubAgentSession(ctx));
    });
 }

package/dist/templates/omp/index.d.ts

@@ -1,4 +1,5 @@
 import type { AgentTemplate } from "../template-utils.js";
 export declare function getAllAgents(): AgentTemplate[];
 export declare function getExtensionTemplate(): string;
+export declare function getConfigTemplate(): string;
 //# sourceMappingURL=index.d.ts.map

package/dist/templates/omp/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/templates/omp/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAI1D,wBAAgB,YAAY,IAAI,aAAa,EAAE,CAE9C;AAED,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/templates/omp/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAI1D,wBAAgB,YAAY,IAAI,aAAa,EAAE,CAE9C;AAED,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C"}

package/dist/templates/omp/index.js

@@ -6,4 +6,7 @@ export function getAllAgents() {
 export function getExtensionTemplate() {
     return readTemplate("extensions/atw/index.ts.txt");
 }
+export function getConfigTemplate() {
+    return readTemplate("config.yml");
+}
 //# sourceMappingURL=index.js.map

package/dist/templates/omp/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/templates/omp/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAG5D,MAAM,EAAE,YAAY,EAAE,YAAY,EAAE,GAAG,oBAAoB,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAE7E,MAAM,UAAU,YAAY;IAC1B,OAAO,YAAY,EAAE,CAAC;AACxB,CAAC;AAED,MAAM,UAAU,oBAAoB;IAClC,OAAO,YAAY,CAAC,6BAA6B,CAAC,CAAC;AACrD,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/templates/omp/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAG5D,MAAM,EAAE,YAAY,EAAE,YAAY,EAAE,GAAG,oBAAoB,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAE7E,MAAM,UAAU,YAAY;IAC1B,OAAO,YAAY,EAAE,CAAC;AACxB,CAAC;AAED,MAAM,UAAU,oBAAoB;IAClC,OAAO,YAAY,CAAC,6BAA6B,CAAC,CAAC;AACrD,CAAC;AAED,MAAM,UAAU,iBAAiB;IAC/B,OAAO,YAAY,CAAC,YAAY,CAAC,CAAC;AACpC,CAAC"}

package/dist/templates/opencode/lib/session-utils.js

@@ -36,8 +36,10 @@ function getTaskStatus(ctx, platformInput = null, general = false) {
     }
     return (
       "Status: NO ACTIVE TASK\n" +
-      "Next-Action: Classify the current turn before creating any ATW task. " +
-      "Simple conversation / small task asks only whether this turn should create an ATW task. " +
+      "Next-Action: If the request is about a task that already exists — the user names it, or asks to continue or accept and only one open task fits — make it this session's task first, as the no-task breadcrumb says; do not ask whether to create a new one. " +
+      "Otherwise classify the current turn before creating any ATW task. " +
+      "Simple conversation / small task asks whether this turn should create an ATW task. " +
+      "In that ask, say what each answer means: without a task there is no requirements document (`prd.md`) and no formal acceptance (each requirement checked with evidence, the user signs off); a task adds writing the requirements, the user confirming the spec, implementing against it, and that acceptance before archiving. " +
       "Complex task asks whether task creation and planning are allowed."
     )
   }

package/dist/templates/opencode/plugins/inject-workflow-state.js

@@ -131,6 +131,7 @@ function promptHasSkipKeyword(text, keyword) {
  * buildBreadcrumb so users see the broken state and fix workflow.md
  * rather than the plugin silently masking it.
  */
+const PLATFORM_MARKER_LINE_RE = /^\[\/?[A-Za-z][^[\]]*\]\s*(?:\n|$)/gm
 function loadBreadcrumbs(directory) {
   const workflowPath = join(directory, ".atw", "workflow.md")
   if (!existsSync(workflowPath)) return {}
@@ -143,7 +144,10 @@ function loadBreadcrumbs(directory) {
   const result = {}
   for (const match of content.matchAll(TAG_RE)) {
     const status = match[1]
-    const body = match[2].trim()
+    // OpenCode has no `[Platform, ...]` block of its own in any breadcrumb, so
+    // it gets every block's lines (each names its tool) with the marker lines
+    // dropped, like select_platform_blocks() for such platforms.
+    const body = match[2].replace(PLATFORM_MARKER_LINE_RE, "").trim()
     if (body) result[status] = body
   }
   return result