@chinhae/atw-cli 0.3.6 → 0.4.0

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

@@ -3,7 +3,7 @@ import { existsSync, readFileSync, readdirSync, statSync } from "fs"
 import { join } from "path"
 import { execFileSync } from "child_process"
 import { platform } from "os"
-import { debugLog } from "./atw-context.js"
+import { debugLog, isGeneralProject } from "./atw-context.js"
 
 const PYTHON_CMD = platform() === "win32" ? "python" : "python3"
 
@@ -18,10 +18,22 @@ The acknowledgment must not alter the language used for the remainder of the res
 This notice is one-shot: do not repeat it after the first visible assistant reply in this session.
 </first-reply-notice>`
 
-function getTaskStatus(ctx, platformInput = null) {
+/**
+ * Compact active-task status and next action. In a `general` project the AI
+ * decides on its own whether a request gets a task, so the no-task line defers
+ * to the workflow instead of telling it to ask first — keep the wording in step
+ * with `_get_task_status` in the shared session-start hook.
+ */
+function getTaskStatus(ctx, platformInput = null, general = false) {
   const active = ctx.getActiveTask(platformInput)
   const taskRef = active.taskPath
   if (!taskRef) {
+    if (general) {
+      return (
+        "Status: NO ACTIVE TASK\n" +
+        "Next-Action: Do what <atw-workflow> above says for a session with no current task."
+      )
+    }
     return (
       "Status: NO ACTIVE TASK\n" +
       "Next-Action: Classify the current turn before creating any ATW task. " +
@@ -50,6 +62,11 @@ function getTaskStatus(ctx, platformInput = null) {
   const taskStatus = taskData.status || "unknown"
 
   if (taskStatus === "completed") {
+    if (general) {
+      // A general task records no branch; without the switch the archive is
+      // refused in a repository that has a remote.
+      return `Status: COMPLETED\nTask: ${taskTitle}\nNext-Action: The archive was interrupted — re-run \`task.py archive <task> --skip-branch-validation\` to finish it.`
+    }
     return `Status: COMPLETED\nTask: ${taskTitle}\nNext-Action: The archive was interrupted — re-run \`task.py archive <task>\` to finish it. If the working tree is dirty, commit or set the task back to \`implement\` first; there is no wrap-up commit step.`
   }
 
@@ -253,11 +270,16 @@ function buildCompactCurrentState(ctx, platformInput, specIndexPaths) {
   const lines = []
   lines.push(`Developer: ${readDeveloper(directory)}`)
 
-  const branch = runGit(directory, ["branch", "--show-current"]) || "(detached)"
-  const dirtyCount = runGit(directory, ["status", "--porcelain"])
-    .split(/\r?\n/)
-    .filter(line => line.trim()).length
-  lines.push(`Git: branch ${branch}; ${dirtyCount === 0 ? "clean" : `dirty ${dirtyCount} paths`}.`)
+  // 普通文件夹没有分支，也谈不上干净：照实说，不编一个状态出来。
+  if (runGit(directory, ["rev-parse", "--is-inside-work-tree"]) !== "true") {
+    lines.push("Git: not a git repository.")
+  } else {
+    const branch = runGit(directory, ["branch", "--show-current"]) || "(detached)"
+    const dirtyCount = runGit(directory, ["status", "--porcelain"])
+      .split(/\r?\n/)
+      .filter(line => line.trim()).length
+    lines.push(`Git: branch ${branch}; ${dirtyCount === 0 ? "clean" : `dirty ${dirtyCount} paths`}.`)
+  }
 
   const active = ctx.getActiveTask(platformInput)
   if (active.taskPath) {
@@ -312,6 +334,32 @@ function buildCompactCurrentState(ctx, platformInput, specIndexPaths) {
   return lines.join("\n")
 }
 
+const CONVENTIONS_PATH = ".atw/spec/conventions.md"
+
+/**
+ * The <conventions> block of a `general` project, else "". Mirrors
+ * conventions_context() in .atw/scripts/common/session_context.py — keep the two
+ * in step: a general project has one flat conventions file instead of
+ * per-package, per-layer guideline indexes, and always gets the block, so the
+ * AI knows where the first entry goes.
+ */
+function buildConventionsContext(directory) {
+  if (!isGeneralProject(directory)) return ""
+  const header =
+    `Source: ${CONVENTIONS_PATH} — what this project's user asked for more than ` +
+    "once. Follow it in every reply."
+  let body = ""
+  try {
+    body = readFileSync(join(directory, CONVENTIONS_PATH), "utf-8").trim()
+  } catch {
+    // Not written yet.
+  }
+  if (!body) {
+    return `<conventions>\n${header} Nothing is written there yet.\n</conventions>`
+  }
+  return `<conventions>\n${header}\n\n${body}\n</conventions>`
+}
+
 export function buildSessionContext(ctx, platformInput = null) {
   const directory = ctx.directory
   const contextKey = typeof ctx.getContextKey === "function"
@@ -320,7 +368,10 @@ export function buildSessionContext(ctx, platformInput = null) {
 
   const config = loadAtwConfig(directory, contextKey)
   const allowedPkgs = resolveSpecScope(config)
-  const paths = collectSpecIndexPaths(directory, allowedPkgs)
+  // A general project keeps no guideline indexes — whatever a switch from dev
+  // left under `.atw/spec/` is not offered there.
+  const conventions = buildConventionsContext(directory)
+  const paths = conventions ? [] : collectSpecIndexPaths(directory, allowedPkgs)
 
   const parts = []
 
@@ -374,26 +425,30 @@ ATW compact SessionStart context. Use it to orient the session; load details on
     parts.push("</atw-workflow>")
   }
 
-  parts.push("<guidelines>")
-  parts.push(
-    "Task context order for implementation/check: jsonl entries -> `prd.md`.\n"
-  )
+  if (conventions) {
+    parts.push(conventions)
+  } else {
+    parts.push("<guidelines>")
+    parts.push(
+      "Task context order for implementation/check: jsonl entries -> `prd.md`.\n"
+    )
 
-  if (paths.length > 0) {
-    parts.push("## Available indexes (read on demand)")
-    for (const p of paths) {
-      parts.push(`- ${p}`)
+    if (paths.length > 0) {
+      parts.push("## Available indexes (read on demand)")
+      for (const p of paths) {
+        parts.push(`- ${p}`)
+      }
+      parts.push("")
     }
-    parts.push("")
-  }
 
-  parts.push(
-    "Discover more via: " +
-    "`python3 ./.atw/scripts/get_context.py --mode packages`"
-  )
-  parts.push("</guidelines>")
+    parts.push(
+      "Discover more via: " +
+      "`python3 ./.atw/scripts/get_context.py --mode packages`"
+    )
+    parts.push("</guidelines>")
+  }
 
-  const taskStatus = getTaskStatus(ctx, platformInput)
+  const taskStatus = getTaskStatus(ctx, platformInput, Boolean(conventions))
   parts.push(`<task-status>\n${taskStatus}\n</task-status>`)
 
   parts.push(`<ready>

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

@@ -29,7 +29,12 @@ import {
   platformInputFromMessages,
   prependEphemeralText,
 } from "../lib/context-visibility.js"
-import { AtwContext, debugLog, isAtwSubagent } from "../lib/atw-context.js"
+import {
+  AtwContext,
+  debugLog,
+  isAtwSubagent,
+  isGeneralProject,
+} from "../lib/atw-context.js"
 
 // Supports STATUS values with letters, digits, underscores, hyphens
 // (so "in-review" / "blocked-by-team" work alongside "task_error").
@@ -177,18 +182,23 @@ const NOOB_MODE_FALLBACK =
   "language, and every term, command or path explained where it appears."
 
 /**
- * The <noob-mode> block for a developer who switched noob mode on, else "".
- * Mirrors noob_mode_reminder() in .atw/scripts/common/noob_mode.py: the
- * switch is a `noob_mode=on` line in the gitignored .atw/.developer.
+ * The <noob-mode> block while noob mode is on for this developer, else "".
+ * Mirrors is_noob_mode_on() / noob_mode_reminder() in
+ * .atw/scripts/common/noob_mode.py — keep the two in step: a `noob_mode=on`
+ * or `noob_mode=off` line in the gitignored .atw/.developer is the
+ * developer's own choice and wins; without one the project mode decides
+ * (on for `general`, off for `dev`).
  */
 function buildNoobModeReminder(directory, templates) {
-  let developer
+  let choice = null
   try {
-    developer = readFileSync(join(directory, ".atw", ".developer"), "utf-8")
+    const developer = readFileSync(join(directory, ".atw", ".developer"), "utf-8")
+    const m = developer.match(/^noob_mode=(.*)$/m)
+    if (m) choice = m[1].trim() === "on"
   } catch {
-    return ""
+    // No identity file: this developer never chose.
   }
-  if (!/^noob_mode=on\s*$/m.test(developer)) return ""
+  if (!(choice ?? isGeneralProject(directory))) return ""
   return `<noob-mode>\n${templates.noob_mode || NOOB_MODE_FALLBACK}\n</noob-mode>`
 }
 

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

@@ -1249,18 +1249,24 @@ function buildStartupContext(
   overview: string,
 ): string {
   const workflow = workflowOverview(root, key);
+  // get_context.py puts a <conventions> block in the overview only for a
+  // `general` project. Its workflow has its own way to pick up unfinished
+  // work; the bare `task.py start` below is one the script refuses there.
+  const ready = overview.includes("\n<conventions>\n")
+    ? [
+        "Do what <atw-workflow> above says for the current task's status. With no current task, it also says when to create one and how to pick up unfinished work.",
+      ]
+    : [
+        "Use the current workflow state to decide whether to create, continue, or skip an ATW task.",
+        "When CURRENT TASK is (none) but ACTIVE TASKS lists exactly one task assigned to you that is already at the implement or accept stage, this window is merely not bound to it yet: run `python3 ./.atw/scripts/task.py start <task-dir>` for that task, then continue from its stage. Do not ask whether to create a new task in that case.",
+        "If several tasks qualify, or the only candidate is still in a planning stage (discover / specify / slice), ask which task to bind instead of running start: start moves a planning-stage task straight into implement.",
+      ];
   return [
     "<session-context>\nATW compact SessionStart context. Use it to orient the session; load details on demand.\n</session-context>",
     FIRST_REPLY_NOTICE,
     overview,
     workflow,
-    [
-      "<ready>",
-      "Use the current workflow state to decide whether to create, continue, or skip an ATW task.",
-      "When CURRENT TASK is (none) but ACTIVE TASKS lists exactly one task assigned to you that is already at the implement or accept stage, this window is merely not bound to it yet: run `python3 ./.atw/scripts/task.py start <task-dir>` for that task, then continue from its stage. Do not ask whether to create a new task in that case.",
-      "If several tasks qualify, or the only candidate is still in a planning stage (discover / specify / slice), ask which task to bind instead of running start: start moves a planning-stage task straight into implement.",
-      "</ready>",
-    ].join("\n"),
+    ["<ready>", ...ready, "</ready>"].join("\n"),
   ]
     .filter(Boolean)
     .join("\n\n");
@@ -1983,9 +1989,14 @@ export default function atwExtension(pi: {
   // Events
   pi.on?.("session_start", (event, ctx) => {
     const k = getKey(event, ctx);
-    inheritSessionPointer(resolveRoot(ctx), k, event);
+    const root = resolveRoot(ctx);
+    inheritSessionPointer(root, k, event);
+    // A `general` project installs no /atw-continue prompt.
+    const canContinue = exists(join(root, ".pi", "prompts", "atw-continue.md"));
     ctx?.ui?.notify?.(
-      "ATW project context is available. Use /atw-start to bootstrap or /atw-continue to resume.",
+      canContinue
+        ? "ATW project context is available. Use /atw-start to bootstrap or /atw-continue to resume."
+        : "ATW project context is available. Use /atw-start to bootstrap.",
       "info",
     );
   });

package/dist/templates/shared-hooks/inject-shell-session-context.py

@@ -4,7 +4,7 @@
 No researched platform exports a session id into its shell tool's child
 process, but every hook-capable one puts that id on hook stdin. So the hook
 that fires just before a shell command writes a short-lived runtime ticket
-whenever the pending command calls `task.py start/current/finish`, and the
+whenever the pending command calls `task.py start/resume/current/finish`, and the
 task script consumes it when it has no native session environment.
 
 Registered on whichever pre-shell event the host provides — Cursor's
@@ -35,7 +35,7 @@ if callable(_stdin_reconfigure):
 DIR_WORKFLOW = ".atw"
 DIR_RUNTIME = ".runtime"
 DIR_SHELL_TICKETS = "shell-tickets"
-SESSION_SUBCOMMANDS = {"start", "current", "finish"}
+SESSION_SUBCOMMANDS = {"start", "resume", "current", "finish"}
 TICKET_TTL_SECONDS = 30
 CONTEXT_IDENTITY_KEYS = (
     "session_id",
@@ -177,7 +177,7 @@ def _extract_task_subcommands(command: str) -> list[dict[str, str]]:
         if name not in SESSION_SUBCOMMANDS:
             continue
         item = {"name": name}
-        if name == "start" and index + 2 < len(tokens):
+        if name in ("start", "resume") and index + 2 < len(tokens):
             item["task_ref"] = tokens[index + 2]
         subcommands.append(item)
     return subcommands

package/dist/templates/shared-hooks/inject-workflow-state.py

@@ -383,8 +383,24 @@ def build_breadcrumb(
     return f"<workflow-state>\n{header}\n{body}\n</workflow-state>"
 
 
+def _is_general_project(root: Path) -> bool:
+    """Whether this is a `general` project, as `common.config` reads the mode.
+
+    An install whose scripts predate project modes is a dev project.
+    """
+    scripts_dir = root / ".atw" / "scripts"
+    if str(scripts_dir) not in sys.path:
+        sys.path.insert(0, str(scripts_dir))
+    try:
+        from common.config import get_project_mode  # type: ignore[import-not-found]
+
+        return get_project_mode(root) == "general"
+    except Exception:
+        return False
+
+
 def _noob_mode_reminder(root: Path) -> str:
-    """The `<noob-mode>` block for a developer who switched noob mode on, else "".
+    """The `<noob-mode>` block while noob mode is on for this developer, else "".
 
     Riding on the per-turn breadcrumb is the point of the feature: a skill
     loaded once fades over a long conversation, this is said again every turn.
@@ -476,7 +492,10 @@ def main() -> int:
         parts: list[str] = []
         if task is None:
             parts.append(CODEX_NO_TASK_BOOTSTRAP_NOTICE)
-        parts.append(_codex_mode_banner(config))
+        # The banner is about dispatching review sub-agents and the dev
+        # implement commands; a general project installs neither.
+        if not _is_general_project(root):
+            parts.append(_codex_mode_banner(config))
         parts.append(breadcrumb)
         breadcrumb = "\n\n".join(parts)
 

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

@@ -83,7 +83,7 @@ FIRST_REPLY_NOTICE = f"{_FIRST_REPLY_NOTICE_HEAD}\n{_FIRST_REPLY_NOTICE_TAIL}"
 
 
 def _noob_mode_reminder(project_dir: Path) -> str:
-    """The `<noob-mode>` block for a developer who switched noob mode on, else "".
+    """The `<noob-mode>` block while noob mode is on for this developer, else "".
 
     Platforms with a per-turn hook hear this again every turn; here it covers
     the ones that only have SessionStart (Cursor) and the first reply of a
@@ -101,6 +101,24 @@ def _noob_mode_reminder(project_dir: Path) -> str:
         return ""
 
 
+def _conventions_context(project_dir: Path) -> str:
+    """The `<conventions>` block of a `general` project, else "".
+
+    A general project has one flat conventions file instead of per-package,
+    per-layer guideline indexes. An install whose scripts predate the helper is
+    treated as a dev project.
+    """
+    scripts_dir = project_dir / ".atw" / "scripts"
+    if str(scripts_dir) not in sys.path:
+        sys.path.insert(0, str(scripts_dir))
+    try:
+        from common.session_context import conventions_context  # type: ignore[import-not-found]
+
+        return conventions_context(project_dir)
+    except Exception:
+        return ""
+
+
 def _build_first_reply_notice(update_hint: str | None) -> str:
     """First-reply notice, carrying the ATW update reminder when there is one.
 
@@ -201,6 +219,9 @@ def _run_git(repo_root: Path, args: list[str]) -> str:
 
 
 def _format_git_state(repo_root: Path) -> str:
+    # 普通文件夹没有分支，也谈不上干净：照实说，不编一个状态出来。
+    if _run_git(repo_root, ["rev-parse", "--is-inside-work-tree"]) != "true":
+        return "Git: not a git repository."
     branch = _run_git(repo_root, ["branch", "--show-current"]) or "(detached)"
     dirty_lines = [
         line for line in _run_git(repo_root, ["status", "--porcelain"]).splitlines()
@@ -416,11 +437,21 @@ def _resolve_task_dir(atw_dir: Path, task_ref: str) -> Path:
     return atw_dir / "tasks" / path_obj
 
 
-def _get_task_status(atw_dir: Path, input_data: dict) -> str:
-    """Return compact active-task status, artifact presence, and next action."""
+def _get_task_status(atw_dir: Path, input_data: dict, general: bool = False) -> str:
+    """Return compact active-task status, artifact presence, and next action.
+
+    In a `general` project the AI decides on its own whether a request gets a
+    task, so the no-task line defers to the workflow instead of telling it to
+    ask first.
+    """
     active = _resolve_active_task(atw_dir, input_data)
 
     if not active.task_path:
+        if general:
+            return (
+                "Status: NO ACTIVE TASK\n"
+                "Next-Action: Do what <atw-workflow> above says for a session with no current task."
+            )
         return (
             "Status: NO ACTIVE TASK\n"
             "Next-Action: Classify the current turn before creating any ATW task. "
@@ -454,6 +485,15 @@ def _get_task_status(atw_dir: Path, input_data: dict) -> str:
     present_line = ", ".join(present) if present else "(none)"
 
     if task_status == "completed":
+        if general:
+            # A general task records no branch; without the switch the archive
+            # is refused in a repository that has a remote.
+            return (
+                f"Status: COMPLETED\nTask: {task_title}\n"
+                f"Present: {present_line}\n"
+                "Next-Action: The archive was interrupted — re-run "
+                "`task.py archive <task> --skip-branch-validation` to finish it."
+            )
         return (
             f"Status: COMPLETED\nTask: {task_title}\n"
             f"Present: {present_line}\n"
@@ -824,7 +864,12 @@ def main():
 
     output = StringIO()
 
-    spec_index_paths = _collect_spec_index_paths(atw_dir, allowed_pkgs)
+    # A general project keeps no guideline indexes — whatever a switch from dev
+    # left under `.atw/spec/` is not offered there.
+    conventions = _conventions_context(project_dir)
+    spec_index_paths = (
+        [] if conventions else _collect_spec_index_paths(atw_dir, allowed_pkgs)
+    )
 
     output.write("""<session-context>
 ATW compact SessionStart context. Use it to orient the session; load details on demand.
@@ -851,27 +896,30 @@ ATW compact SessionStart context. Use it to orient the session; load details on
     output.write(_build_workflow_overview(atw_dir / "workflow.md"))
     output.write("\n</atw-workflow>\n\n")
 
-    output.write("<guidelines>\n")
-    # D32/C23: same as `_get_task_status` — the injected order is jsonl then
-    # `prd.md`; `design.md` / `implement.md` are no longer materialized.
-    output.write(
-        "Task context order for implementation/check: jsonl entries -> `prd.md`.\n\n"
-    )
+    if conventions:
+        output.write(f"{conventions}\n\n")
+    else:
+        output.write("<guidelines>\n")
+        # D32/C23: same as `_get_task_status` — the injected order is jsonl then
+        # `prd.md`; `design.md` / `implement.md` are no longer materialized.
+        output.write(
+            "Task context order for implementation/check: jsonl entries -> `prd.md`.\n\n"
+        )
 
-    if spec_index_paths:
-        output.write("## Available indexes (read on demand)\n")
-        for p in spec_index_paths:
-            output.write(f"- {p}\n")
-        output.write("\n")
-
-    output.write(
-        "Discover more via: "
-        "`python3 ./.atw/scripts/get_context.py --mode packages`\n"
-    )
-    output.write("</guidelines>\n\n")
+        if spec_index_paths:
+            output.write("## Available indexes (read on demand)\n")
+            for p in spec_index_paths:
+                output.write(f"- {p}\n")
+            output.write("\n")
+
+        output.write(
+            "Discover more via: "
+            "`python3 ./.atw/scripts/get_context.py --mode packages`\n"
+        )
+        output.write("</guidelines>\n\n")
 
     # Check task status and inject structured tag
-    task_status = _get_task_status(atw_dir, hook_input)
+    task_status = _get_task_status(atw_dir, hook_input, general=bool(conventions))
     output.write(f"<task-status>\n{task_status}\n</task-status>\n\n")
 
     output.write("""<ready>

package/dist/templates/snow/SNOW.md

@@ -1,5 +1,6 @@
 # ATW on Snow CLI
 
+{{^MODE_GENERAL}}
 Snow is a **class-1** ATW host: auto context inject + project agent discovery +
 `beforeSubAgentStart` prompt enrichment.
 
@@ -38,6 +39,35 @@ Primary path: project agent discovery — no manual merge required. Do not use l
 
 Context loading is class-1 hook inject (`beforeSubAgentStart` / session / user). Agents are **not** shipped with class-2 pull-based prelude text. Hooks already inject context; agents still re-read task artifacts for correctness.
 
+{{/MODE_GENERAL}}
+{{#MODE_GENERAL}}
+Snow is a **class-1** ATW host: hooks inject ATW context into every session
+and every message.
+
+This project is in ATW's `general` mode, for work that is not code: you say
+what you want in your own words, and the workflow in `.atw/workflow.md` has
+the AI do the rest. There are no prompt commands to run and no project agents.
+
+| Capability                                 | Status                                                                       |
+| ------------------------------------------ | ---------------------------------------------------------------------------- |
+| Skills (`.snow/skills/atw-*/SKILL.md`)     | Works — the six skills of `general` mode                                     |
+| Context hooks (`.snow/hooks/`)             | Inject model context via stdout JSON + write `.snow/log/atw-context.txt`     |
+| Prompt commands, project agents            | None in `general` mode                                                       |
+
+## Quick start
+
+```bash
+atw init --snow --mode general -u your-name
+snow
+```
+
+In Snow:
+
+1. Open a session in the project root — `onSessionStart` injects ATW context automatically, including what `.atw/spec/conventions.md` says and, unless you turned it off, the plain-language reminder.
+2. Say what you want done. The AI keeps the task record, shows you what it wrote down before it starts, checks the result with you, and files it when you accept.
+3. Debug injects: set `SNOW_DEBUG_HOOKS=1` and inspect `.snow/log/hooks-inject.txt`.
+
+{{/MODE_GENERAL}}
 ## Tool names (Snow-native)
 
 - `filesystem-read` / `filesystem-create` / `filesystem-replaceedit` / `filesystem-edit`

package/dist/templates/snow/hooks/write-atw-context.py

@@ -434,6 +434,40 @@ def _workflow_phase_summary(
     return lines
 
 
+def _conventions_context(repo: Path) -> str:
+    """The `<conventions>` block of a `general` project, else "".
+
+    Same entry the shared session-start hook uses. An install whose scripts
+    predate the helper is treated as a dev project.
+    """
+    scripts_dir = repo / ".atw" / "scripts"
+    if str(scripts_dir) not in sys.path:
+        sys.path.insert(0, str(scripts_dir))
+    try:
+        from common.session_context import conventions_context  # type: ignore[import-not-found]
+
+        return conventions_context(repo)
+    except Exception:
+        return ""
+
+
+def _noob_mode_reminder(repo: Path) -> str:
+    """The `<noob-mode>` block while noob mode is on for this developer, else "".
+
+    Same entry the shared hooks use. An install whose scripts predate the
+    helper simply has no noob mode.
+    """
+    scripts_dir = repo / ".atw" / "scripts"
+    if str(scripts_dir) not in sys.path:
+        sys.path.insert(0, str(scripts_dir))
+    try:
+        from common.noob_mode import noob_mode_reminder  # type: ignore[import-not-found]
+
+        return noob_mode_reminder(repo)
+    except Exception:
+        return ""
+
+
 def build_context(
     repo: Path,
     *,
@@ -468,6 +502,20 @@ def build_context(
             lines.append(f"Dispatch prompt (truncated): {p}")
         lines.append("")
 
+    # A general project has no session-start entry on Snow (the hooks replace
+    # it), so its conventions and the plain-language reminder reach the main
+    # session here or not at all. A dev project's context stays as it was,
+    # which on Snow has never included the plain-language reminder.
+    conventions = _conventions_context(repo) if mode != "subagent" else ""
+    general = bool(conventions)
+    if general:
+        # Ahead of the task state and the excerpts, so the byte limit can never
+        # cut it off; said again on every user message, like the per-turn hook
+        # of other platforms.
+        noob_mode = _noob_mode_reminder(repo)
+        if noob_mode:
+            lines.extend(["", noob_mode, ""])
+
     task_py = repo / ".atw" / "scripts" / "task.py"
     current = ""
     task_dir: Path | None = None
@@ -492,6 +540,11 @@ def build_context(
         lines.append("(could not resolve active task directory from task.py output)")
         lines.append("")
 
+    if general and not compact:
+        # Ahead of the excerpts below: when the file is long, they are what the
+        # byte limit drops, and the block's first line still says where to read.
+        lines.extend([conventions, ""])
+
     if not compact:
         lines.extend(_workflow_phase_summary(repo, stdin_ctx))
 
@@ -546,6 +599,17 @@ def build_context(
                 "",
             ]
         )
+    elif general:
+        # No sub-agents and no start entry are installed in a general project.
+        lines.extend(
+            [
+                "## Main-session checklist",
+                "1. Session/user hooks auto-inject ATW context."
+                if not compact
+                else "1. Compact inject — full context also at `.snow/log/atw-context.txt`.",
+                "",
+            ]
+        )
     else:
         lines.extend(
             [

package/dist/utils/manifest-prune.d.ts

@@ -49,7 +49,8 @@ export interface PruneOptions {
 /**
  * Walk the manifest and split it into kept vs pruned entries.
  *
- * @param cwd  Project root — used to save the rewritten manifest.
+ * @param cwd  Project root — used to read the project's mode and to save the
+ *   rewritten manifest.
  * @param configuredPlatforms Output of `getConfiguredPlatforms(cwd)` — caller
  *   resolves this so we don't have to re-walk the filesystem.
  * @param hashes Already-loaded manifest contents. Passing it in (vs reading

package/dist/utils/manifest-prune.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifest-prune.d.ts","sourceRoot":"","sources":["../../src/utils/manifest-prune.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAWH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,MAAM,WAAW,WAAW;IAC1B,0DAA0D;IAC1D,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,6EAA6E;IAC7E,MAAM,EAAE,cAAc,CAAC;CACxB;AAoDD,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,MAAM,EACX,mBAAmB,EAAE,SAAS,MAAM,EAAE,EACtC,MAAM,EAAE,cAAc,EACtB,OAAO,GAAE,YAAiB,GACzB,WAAW,CAmCb"}
+{"version":3,"file":"manifest-prune.d.ts","sourceRoot":"","sources":["../../src/utils/manifest-prune.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAYH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,MAAM,WAAW,WAAW;IAC1B,0DAA0D;IAC1D,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,6EAA6E;IAC7E,MAAM,EAAE,cAAc,CAAC;CACxB;AAsDD,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,MAAM,EACX,mBAAmB,EAAE,SAAS,MAAM,EAAE,EACtC,MAAM,EAAE,cAAc,EACtB,OAAO,GAAE,YAAiB,GACzB,WAAW,CAmCb"}