@chinhae/atw-cli 0.1.0

package/dist/templates/opencode/plugins/inject-subagent-context.js

@@ -0,0 +1,390 @@
+/* global process */
+/**
+ * ATW Context Injection Plugin
+ *
+ * Injects context when Task tool is called with supported subagent types.
+ * Uses OpenCode's tool.execute.before hook.
+ */
+
+import { existsSync } from "fs"
+import { join } from "path"
+import {
+  AtwContext,
+  debugLog,
+  readContextInjectionLimits,
+  ContextBudget,
+  materializeArtifact,
+} from "../lib/atw-context.js"
+
+// Supported subagent types, `atw-` prefix stripped (see below). These must
+// stay in step with AGENTS_ALL in shared-hooks/inject-subagent-context.py,
+// which is the authority: this list drifted to the pre-M1 role names once and
+// nothing raised — every dispatch simply fell through the whitelist and
+// injection never fired. `research` is retired as a sub-agent (C5).
+const AGENTS_ALL = ["implement-agent", "review"]
+const AGENTS_REQUIRE_TASK = ["implement-agent", "review"]
+
+// Match `Active task: <path>` on the first non-empty line of the dispatch
+// prompt. Mirrors the contract in workflow.md's [workflow-state:implement]
+// breadcrumb so multi-window users can disambiguate which task is targeted.
+const ACTIVE_TASK_HINT_RE = /^\s*Active task:\s*(\S+)\s*$/m
+
+function extractActiveTaskHint(prompt) {
+  if (typeof prompt !== "string" || !prompt) return null
+  const match = prompt.match(ACTIVE_TASK_HINT_RE)
+  return match ? match[1].trim() : null
+}
+
+/**
+ * Get context for implement agent. `taskDir` may be relative
+ * (`.atw/tasks/foo`) or absolute; both are resolved via
+ * `ctx.resolveTaskDir`.
+ *
+ * Read order (mirrors Python `get_implement_context`):
+ *   1. All files in implement.jsonl (spec/research manifests)
+ *   2. prd.md (requirements)
+ * `design.md` / `implement.md` are not materialized (D32/C23): nothing writes
+ * them, and a reader that still reaches for them is what keeps the cut from
+ * landing. Mirrors Python `get_implement_context`.
+ * All blocks share one total budget.
+ */
+function getImplementContext(ctx, taskDir) {
+  const parts = []
+  const taskDirFull = ctx.resolveTaskDir(taskDir)
+  if (!taskDirFull) return ""
+
+  const limits = readContextInjectionLimits(ctx.directory)
+  const budget = new ContextBudget(limits.max_total_bytes)
+
+  // 1. Read implement.jsonl
+  const jsonlPath = join(taskDirFull, "implement.jsonl")
+  const blocks = ctx.readJsonlWithFiles(jsonlPath, limits, budget)
+  if (blocks.length > 0) {
+    parts.push(ctx.buildContextFromEntries(blocks))
+  }
+
+  // 2. Requirements document
+  const prdBlock = materializeArtifact(
+    ctx.directory,
+    `${taskDir}/prd.md`,
+    `${taskDir}/prd.md (Requirements)`,
+    "Requirements document",
+    limits,
+    budget,
+  )
+  if (prdBlock) parts.push(prdBlock)
+
+  return parts.join("\n\n")
+}
+
+/**
+ * Get context for check agent. `taskDir` may be relative or absolute.
+ * Same read order and shared budget as the implement context.
+ */
+function getCheckContext(ctx, taskDir) {
+  const parts = []
+  const taskDirFull = ctx.resolveTaskDir(taskDir)
+  if (!taskDirFull) return ""
+
+  const limits = readContextInjectionLimits(ctx.directory)
+  const budget = new ContextBudget(limits.max_total_bytes)
+
+  const jsonlPath = join(taskDirFull, "check.jsonl")
+  const blocks = ctx.readJsonlWithFiles(jsonlPath, limits, budget)
+  if (blocks.length > 0) {
+    parts.push(ctx.buildContextFromEntries(blocks))
+  }
+
+  const prdBlock = materializeArtifact(
+    ctx.directory,
+    `${taskDir}/prd.md`,
+    `${taskDir}/prd.md (Requirements)`,
+    "Requirements document",
+    limits,
+    budget,
+  )
+  if (prdBlock) parts.push(prdBlock)
+
+  return parts.join("\n\n")
+}
+
+/**
+ * Build enhanced prompt with context
+ */
+function buildPrompt(agentType, originalPrompt, context) {
+  const templates = {
+    "implement-agent": `<!-- atw-hook-injected -->
+# Implement Agent Task
+
+You are the Implement Agent in the Multi-Agent Pipeline.
+
+## Your Context
+
+${context}
+
+---
+
+## Your Task
+
+${originalPrompt}
+
+---
+
+## Workflow
+
+1. **Understand specs** - All dev specs are injected above
+2. **Understand task artifacts** - Read requirements, technical design if present, and execution plan if present
+3. **Implement feature** - Follow specs and task artifacts
+4. **Self-check** - Ensure code quality
+
+## Important Constraints
+
+- Do NOT execute git commit
+- Follow all dev specs injected above
+- Report list of modified/created files when done`,
+
+    review: `<!-- atw-hook-injected -->
+# Check Agent Task
+
+You are the Check Agent in the Multi-Agent Pipeline.
+
+## Your Context
+
+${context}
+
+---
+
+## Your Task
+
+${originalPrompt}
+
+---
+
+## Workflow
+
+1. **Get changes** - Run \`git diff --name-only\` and \`git diff\`
+2. **Check against specs** - Check item by item
+3. **Self-fix** - Fix issues directly, don't just report
+4. **Run verification** - Run lint and typecheck
+
+## Important Constraints
+
+- Fix issues yourself, don't just report
+- Must execute complete checklist`,
+  }
+
+  return templates[agentType] || originalPrompt
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`
+}
+
+function powershellQuote(value) {
+  return `'${String(value).replace(/'/g, "''")}'`
+}
+
+function envValue(env, key) {
+  const value = env?.[key]
+  return typeof value === "string" && value.trim() ? value.trim() : null
+}
+
+function shellBasename(value) {
+  return value.replace(/\\/g, "/").split("/").pop()?.toLowerCase() || ""
+}
+
+function isWindowsPosixShell(env = process.env) {
+  if (envValue(env, "MSYSTEM")) return true
+  if (envValue(env, "MINGW_PREFIX")) return true
+  if (envValue(env, "OPENCODE_GIT_BASH_PATH")) return true
+
+  const ostype = envValue(env, "OSTYPE")?.toLowerCase() || ""
+  if (/(msys|mingw|cygwin)/.test(ostype)) return true
+
+  const shell = shellBasename(envValue(env, "SHELL") || "")
+  return /^(bash|sh|zsh)(\.exe)?$/.test(shell)
+}
+
+function buildAtwContextPrefix(contextKey, hostPlatform = process.platform, env = process.env) {
+  if (hostPlatform === "win32" && !isWindowsPosixShell(env)) {
+    return `$env:ATW_CONTEXT_ID = ${powershellQuote(contextKey)}; `
+  }
+
+  return `export ATW_CONTEXT_ID=${shellQuote(contextKey)}; `
+}
+
+function getBashCommandKey(args) {
+  if (!args || typeof args !== "object") return null
+  if (typeof args.command === "string") return "command"
+  if (typeof args.cmd === "string") return "cmd"
+  return null
+}
+
+function commandStartsWithAtwContext(command) {
+  const firstCommand = command.trimStart().split(/[;&|]/, 1)[0].trimStart()
+  return (
+    /^ATW_CONTEXT_ID\s*=/.test(firstCommand) ||
+    /^export\s+ATW_CONTEXT_ID\s*=/.test(firstCommand) ||
+    /^env\s+(?:(?:-\S+|[A-Za-z_][A-Za-z0-9_]*=\S*)\s+)*ATW_CONTEXT_ID\s*=/.test(firstCommand) ||
+    /^\$env:ATW_CONTEXT_ID\s*=/i.test(firstCommand)
+  )
+}
+
+/**
+ * OpenCode exposes no session identity to Bash at all — it sets no session env
+ * var in any process. The plugin hook does receive it, so inject it into Bash
+ * commands before execution; that prefix is the only channel by which an
+ * AI-run `task.py` sees the OpenCode session.
+ */
+function injectAtwContextIntoBash(ctx, input, output, hostPlatform, env) {
+  const args = output?.args
+  const commandKey = getBashCommandKey(args)
+  if (!commandKey) return false
+
+  const command = args[commandKey]
+  if (!command.trim()) return false
+  if (commandStartsWithAtwContext(command)) return false
+
+  const contextKey = ctx.getContextKey(input)
+  if (!contextKey) return false
+
+  args[commandKey] = `${buildAtwContextPrefix(contextKey, hostPlatform, env)}${command}`
+  return true
+}
+
+// OpenCode plugin factory: `export default async (input) => hooks`.
+// OpenCode 1.2.x iterates every module export and invokes it as a function
+// (packages/opencode/src/plugin/index.ts — `for ([_, fn] of Object.entries(mod)) await fn(input)`);
+// the previous `{ id, server }` object shape failed with
+// `TypeError: fn is not a function` in 1.2.x.
+export default async ({ directory, platform: hostPlatform = process.platform, env = process.env }) => {
+  const ctx = new AtwContext(directory)
+  debugLog("inject", "Plugin loaded, directory:", directory)
+
+  return {
+      "tool.execute.before": async (input, output) => {
+        try {
+          if (process.env.ATW_HOOKS === "0" || process.env.ATW_DISABLE_HOOKS === "1") {
+            return
+          }
+          debugLog("inject", "tool.execute.before called, tool:", input?.tool)
+
+          const toolName = input?.tool?.toLowerCase()
+          if (toolName === "bash") {
+            if (injectAtwContextIntoBash(ctx, input, output, hostPlatform, env)) {
+              debugLog("inject", "Injected ATW_CONTEXT_ID into Bash command")
+            }
+            return
+          }
+
+          if (toolName !== "task") {
+            return
+          }
+
+          const args = output?.args
+          if (!args) return
+
+          const rawSubagentType = args.subagent_type
+          // Agent ids carry an "atw-" prefix; the dispatch table below does not.
+          const subagentType = (rawSubagentType || "").replace(/^atw-/, "")
+          const originalPrompt = args.prompt || ""
+
+          debugLog("inject", "Task tool called, subagent_type:", rawSubagentType)
+
+          if (!AGENTS_ALL.includes(subagentType)) {
+            debugLog("inject", "Skipping - unsupported subagent_type")
+            return
+          }
+
+          // Resolve active task in this priority order (only later steps
+          // run when earlier ones miss):
+          //   1. Exact session runtime context lookup for input.sessionID
+          //   2. `Active task: <path>` hint in the dispatch prompt
+          //      (explicit per-dispatch override — beats single-session
+          //      inference so multi-window users can disambiguate)
+          //   3. Single-session fallback — only when exactly 1 session
+          //      runtime file exists locally
+          let taskDir = null
+          let taskSource = null
+
+          const contextKey = ctx.getContextKey(input)
+          if (contextKey) {
+            const context = ctx.readContext(contextKey)
+            const exactRef = ctx.normalizeTaskRef(context?.current_task || "")
+            if (exactRef) {
+              taskDir = exactRef
+              taskSource = `session:${contextKey}`
+            }
+          }
+
+          if (!taskDir) {
+            const hintRef = extractActiveTaskHint(originalPrompt)
+            if (hintRef) {
+              const hintNormalized = ctx.normalizeTaskRef(hintRef)
+              if (hintNormalized) {
+                const hintDir = ctx.resolveTaskDir(hintNormalized)
+                if (hintDir && existsSync(hintDir)) {
+                  taskDir = hintNormalized
+                  taskSource = "prompt-hint"
+                  debugLog("inject", "Resolved task from Active task: hint:", hintNormalized)
+                }
+              }
+            }
+          }
+
+          if (!taskDir) {
+            const fallback = ctx._resolveSingleSessionFallback()
+            if (fallback?.taskPath) {
+              const fallbackDir = ctx.resolveTaskDir(fallback.taskPath)
+              if (fallbackDir && existsSync(fallbackDir)) {
+                taskDir = fallback.taskPath
+                taskSource = fallback.source
+                debugLog("inject", "Resolved task via single-session fallback:", taskDir, "source:", taskSource)
+              }
+            }
+          }
+
+          // Agents requiring task directory
+          if (AGENTS_REQUIRE_TASK.includes(subagentType)) {
+            // subagentType is already stripped of "atw-" prefix above
+            if (!taskDir) {
+              debugLog("inject", "Skipping - no current task")
+              return
+            }
+            const taskDirFull = ctx.resolveTaskDir(taskDir)
+            if (!taskDirFull || !existsSync(taskDirFull)) {
+              debugLog("inject", "Skipping - task directory not found")
+              return
+            }
+          }
+
+          // Get context based on agent type
+          let context = ""
+          switch (subagentType) {
+            case "implement-agent":
+              context = getImplementContext(ctx, taskDir)
+              break
+            case "review":
+              context = getCheckContext(ctx, taskDir)
+              break
+          }
+
+          if (!context) {
+            debugLog("inject", "No context to inject")
+            return
+          }
+
+          const newPrompt = buildPrompt(subagentType, originalPrompt, context)
+
+          // Mutate args in-place — whole-object replacement does NOT work for the task tool
+          // because the runtime holds a local reference to the same args object.
+          args.prompt = newPrompt
+
+          debugLog("inject", "Injected context for", subagentType, "prompt length:", newPrompt.length)
+
+        } catch (error) {
+          debugLog("inject", "Error in tool.execute.before:", error.message, error.stack)
+        }
+      }
+    }
+}

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

@@ -0,0 +1,240 @@
+/* global process */
+/**
+ * ATW Workflow State Injection Plugin
+ *
+ * Per-turn UserPromptSubmit equivalent for OpenCode.
+ *
+ * On every model request, inject a short <workflow-state> breadcrumb
+ * into the in-memory copy of the latest user message via
+ * `experimental.chat.messages.transform`. Stored history and the TUI
+ * are not modified. Breadcrumb text is pulled exclusively
+ * from the project's workflow.md [workflow-state:STATUS] tag blocks —
+ * workflow.md is the single source of truth. There are no fallback
+ * tables in this plugin: when workflow.md is missing or a tag is
+ * absent, the breadcrumb degrades to a generic
+ * "Refer to workflow.md for current step." line so users see (and fix)
+ * the broken state instead of the plugin silently masking it.
+ *
+ * Silently skips when:
+ *   - No .atw/ directory
+ *   - No active task in the session runtime context
+ *   - task.json malformed or missing status
+ */
+
+import { existsSync, readFileSync } from "fs"
+import { join } from "path"
+import {
+  MESSAGES_TRANSFORM_HOOK,
+  latestUserPromptText,
+  platformInputFromMessages,
+  prependEphemeralText,
+} from "../lib/context-visibility.js"
+import { AtwContext, debugLog, isAtwSubagent } from "../lib/atw-context.js"
+
+// Supports STATUS values with letters, digits, underscores, hyphens
+// (so "in-review" / "blocked-by-team" work alongside "task_error").
+const TAG_RE = /\[workflow-state:([A-Za-z0-9_-]+)\]\s*\n([\s\S]*?)\n\s*\[\/workflow-state:\1\]/g
+
+// Escape hatch for the per-turn breadcrumb. Mirrors
+// `common.config.get_prompt_injection_config()` / the shared Python hook's
+// `_resolve_skip_keyword()` + `prompt_has_skip_keyword()`.
+const DEFAULT_PROMPT_INJECTION_SKIP_KEYWORD = "no-atw"
+
+function stripInlineComment(value) {
+  let inQuote = null
+  for (let idx = 0; idx < value.length; idx++) {
+    const ch = value[idx]
+    if (inQuote) {
+      if (ch === inQuote) inQuote = null
+      continue
+    }
+    if (ch === '"' || ch === "'") {
+      inQuote = ch
+      continue
+    }
+    if (ch === "#" && (idx === 0 || /\s/.test(value[idx - 1]))) return value.slice(0, idx)
+  }
+  return value
+}
+
+function unquoteYaml(s) {
+  if (s.length >= 2 && s[0] === s[s.length - 1] && (s[0] === '"' || s[0] === "'")) return s.slice(1, -1)
+  return s
+}
+
+/**
+ * Line-based parser for ONLY the `prompt_injection:` block of
+ * `.atw/config.yaml`. Not a general YAML parser — mirrors
+ * `common.config.get_prompt_injection_config()` semantics for this section
+ * only (missing key keeps the default; non-string value keeps the default).
+ */
+function readSkipKeyword(directory) {
+  const path = join(directory, ".atw", "config.yaml")
+  if (!existsSync(path)) return DEFAULT_PROMPT_INJECTION_SKIP_KEYWORD
+  let text
+  try {
+    text = readFileSync(path, "utf-8")
+  } catch {
+    return DEFAULT_PROMPT_INJECTION_SKIP_KEYWORD
+  }
+
+  let inSection = false
+  let sectionIndent = -1
+  for (const rawLine of text.split(/\r?\n/)) {
+    const trimmed = rawLine.trim()
+    if (!inSection) {
+      if (/^prompt_injection\s*:\s*(#.*)?$/.test(trimmed)) {
+        inSection = true
+        sectionIndent = rawLine.length - rawLine.trimStart().length
+      }
+      continue
+    }
+    if (!trimmed || trimmed.startsWith("#")) continue
+    const indent = rawLine.length - rawLine.trimStart().length
+    if (indent <= sectionIndent) break
+    const m = trimmed.match(/^skip_keyword\s*:\s*(.*)$/)
+    if (!m) continue
+    return unquoteYaml(stripInlineComment(m[1]).trim())
+  }
+  return DEFAULT_PROMPT_INJECTION_SKIP_KEYWORD
+}
+
+/**
+ * Case-insensitive, word-boundary match of `keyword` in `text`. Hyphen
+ * counts as a word char so "no-atwx" / "xno-atw" don't match, but
+ * punctuation/whitespace boundaries do. Empty keyword never matches.
+ */
+function promptHasSkipKeyword(text, keyword) {
+  if (!keyword || typeof text !== "string") return false
+  const escaped = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+  const pattern = new RegExp(`(?<![\\w-])${escaped}(?![\\w-])`, "i")
+  return pattern.test(text)
+}
+
+/**
+ * Parse workflow.md for [workflow-state:STATUS] blocks.
+ *
+ * Returns {status: body}. workflow.md is the single source of truth —
+ * there are no fallback tables here. Missing tags (or a missing /
+ * unreadable workflow.md) fall back to a generic line in
+ * buildBreadcrumb so users see the broken state and fix workflow.md
+ * rather than the plugin silently masking it.
+ */
+function loadBreadcrumbs(directory) {
+  const workflowPath = join(directory, ".atw", "workflow.md")
+  if (!existsSync(workflowPath)) return {}
+  let content
+  try {
+    content = readFileSync(workflowPath, "utf-8")
+  } catch {
+    return {}
+  }
+  const result = {}
+  for (const match of content.matchAll(TAG_RE)) {
+    const status = match[1]
+    const body = match[2].trim()
+    if (body) result[status] = body
+  }
+  return result
+}
+
+/**
+ * Get (taskId, status) from active task, or null if no active task.
+ */
+function getActiveTask(ctx, platformInput = null) {
+  const active = ctx.getActiveTask(platformInput)
+  const taskRef = active.taskPath
+  if (!taskRef) return null
+  const taskDir = ctx.resolveTaskDir(taskRef)
+  if (active.stale || !taskDir || !existsSync(taskDir)) {
+    return { id: taskRef.split("/").pop(), status: "stale", source: active.source }
+  }
+  const taskJsonPath = join(taskDir, "task.json")
+  if (!existsSync(taskJsonPath)) return null
+  try {
+    const data = JSON.parse(readFileSync(taskJsonPath, "utf-8"))
+    const status = typeof data.status === "string" ? data.status : ""
+    if (!status) return null
+    const id = data.id || taskRef.split("/").pop()
+    return { id, status, source: active.source }
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Build the <workflow-state>...</workflow-state> block.
+ * - Known status (tag present in workflow.md) → detailed body
+ * - Unknown status (no tag, or workflow.md missing) → generic
+ *   "Refer to workflow.md for current step." line
+ * - no_task pseudo-status (id === null) → header omits task info
+ */
+function buildBreadcrumb(id, status, templates) {
+  let body = templates[status]
+  if (body === undefined) {
+    body = "Refer to workflow.md for current step."
+  }
+  let header = id === null ? `Status: ${status}` : `Task: ${id} (${status})`
+  return `<workflow-state>\n${header}\n${body}\n</workflow-state>`
+}
+
+// OpenCode 1.2.x expects plugins to be factory functions (see inject-subagent-context.js comment).
+export default async ({ directory }) => {
+  const ctx = new AtwContext(directory)
+  debugLog("workflow-state", "Plugin loaded, directory:", directory)
+
+  return {
+      [MESSAGES_TRANSFORM_HOOK]: async (_input, output) => {
+        try {
+          const messages = output?.messages
+          const platformInput = platformInputFromMessages(messages)
+          // Skip ATW sub-agent turns — the per-turn breadcrumb is for the
+          // main session only; sub-agent context comes from the parent's
+          // tool.execute.before injection.
+          if (isAtwSubagent(platformInput)) {
+            debugLog("workflow-state", "Skipping atw subagent turn:", platformInput?.agent)
+            return
+          }
+          if (process.env.ATW_HOOKS === "0" || process.env.ATW_DISABLE_HOOKS === "1") {
+            return
+          }
+          if (process.env.OPENCODE_NON_INTERACTIVE === "1") {
+            return
+          }
+          if (!ctx.isAtwProject()) {
+            return
+          }
+
+          const originalText = latestUserPromptText(messages)
+
+          // Escape hatch: user prompt contains the skip keyword
+          // as a standalone word — emit nothing for this turn only.
+          if (promptHasSkipKeyword(originalText, readSkipKeyword(directory))) {
+            debugLog("workflow-state", "Skipping turn: skip keyword present in prompt")
+            return
+          }
+
+          const templates = loadBreadcrumbs(directory)
+          const task = getActiveTask(ctx, platformInput)
+          const breadcrumb = task
+            ? buildBreadcrumb(task.id, task.status, templates, task.source)
+            : buildBreadcrumb(null, "no_task", templates)
+
+          prependEphemeralText(messages, breadcrumb)
+          debugLog(
+            "workflow-state",
+            "Injected breadcrumb for task",
+            task ? task.id : "none",
+            "status",
+            task ? task.status : "no_task",
+          )
+        } catch (error) {
+          debugLog(
+            "workflow-state",
+            "Error in messages.transform:",
+            error instanceof Error ? error.message : String(error),
+          )
+        }
+      },
+  }
+}

package/dist/templates/opencode/plugins/session-start.js

@@ -0,0 +1,65 @@
+/* global process */
+/**
+ * ATW Session Start Plugin
+ *
+ * Injects compact SessionStart context into the copy of the latest user
+ * message that OpenCode sends to the model. Uses
+ * `experimental.chat.messages.transform` so TUI / Web / SQLite history
+ * stay untouched.
+ */
+
+import { AtwContext, debugLog, isAtwSubagent } from "../lib/atw-context.js"
+import {
+  MESSAGES_TRANSFORM_HOOK,
+  platformInputFromMessages,
+  prependEphemeralText,
+  transcriptHasAssistantMessage,
+} from "../lib/context-visibility.js"
+import { buildSessionContext } from "../lib/session-utils.js"
+
+const FIRST_REPLY_NOTICE_RE = /<first-reply-notice>[\s\S]*?<\/first-reply-notice>\s*/g
+
+function stripFirstReplyNotice(context) {
+  return context.replace(FIRST_REPLY_NOTICE_RE, "")
+}
+
+// OpenCode 1.2.x expects plugins to be factory functions (see inject-subagent-context.js comment).
+export default async ({ directory }) => {
+  const ctx = new AtwContext(directory)
+  debugLog("session", "Plugin loaded, directory:", directory)
+
+  return {
+    [MESSAGES_TRANSFORM_HOOK]: async (_input, output) => {
+      try {
+        const messages = output?.messages
+        const platformInput = platformInputFromMessages(messages)
+        const agent = platformInput?.agent || "unknown"
+        debugLog("session", "messages.transform called, agent:", agent)
+
+        if (isAtwSubagent(platformInput)) {
+          debugLog("session", "Skipping atw subagent turn:", agent)
+          return
+        }
+
+        if (process.env.ATW_HOOKS === "0" || process.env.ATW_DISABLE_HOOKS === "1") {
+          debugLog("session", "Skipping - ATW_HOOKS disabled")
+          return
+        }
+
+        if (process.env.OPENCODE_NON_INTERACTIVE === "1") {
+          debugLog("session", "Skipping - non-interactive mode")
+          return
+        }
+
+        let context = buildSessionContext(ctx, platformInput)
+        if (transcriptHasAssistantMessage(messages)) {
+          context = stripFirstReplyNotice(context)
+        }
+        debugLog("session", "Built context, length:", context.length)
+        prependEphemeralText(messages, context)
+      } catch (error) {
+        debugLog("session", "Error in messages.transform:", error.message, error.stack)
+      }
+    },
+  }
+}