cowork-flow 0.0.20 → 0.0.21

package/template/.claude/settings.json

@@ -0,0 +1,24 @@
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": ".cowork-flow/run python .claude/hooks/inject-workflow-state.py"
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": ".cowork-flow/run python .claude/hooks/inject-workflow-state.py"
+          }
+        ]
+      }
+    ]
+  }
+}

package/template/.claude/skills/before-dev/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: before-dev
+description: Use before writing code in a cowork-flow project to load project-specific guidelines, active task context, and verification expectations.
+---
+
+# Before Dev
+
+Use this immediately before code edits.
+
+## Read
+
+1. `AGENTS.md`
+2. `.cowork-flow/workflow.md`
+3. Active task `prd.md`
+4. Active task `implement.jsonl`
+5. Relevant `.cowork-flow/spec/*/index.md`
+6. Any exact files named by the task, plan, or user
+
+Do not bulk-load unrelated tasks, archived sessions, or every spec file.
+
+## Confirm
+
+State briefly:
+
+- Assumptions.
+- Success criteria.
+- Files or modules likely to change.
+- Verification command you expect to run.
+- Whether fixed agents or inline work are appropriate.
+
+If the task is a bounded subagent prompt, do not convert it into main-session planning.

package/template/.claude/skills/brainstorming/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: brainstorming
+description: Use when requirements are unclear, a requested change has multiple valid approaches, or the user wants to shape an idea before implementation.
+---
+
+# Brainstorming
+
+Use this skill as the active clarification gate for new requirements. Turn an idea into a clear change request before PRD, planning, fixed-agent dispatch, or code changes begin.
+
+## Flow
+
+1. Read only the context needed to understand the project area: `AGENTS.md`, `.cowork-flow/workflow.md`, and relevant spec indexes.
+2. State the goal, non-goals, assumptions, scope boundary, success criteria, and the smallest useful scope.
+3. Ask one high-value question only when the answer cannot be inferred safely; otherwise proceed with explicit assumptions.
+4. Present 2-3 viable approaches when trade-offs matter, with a concrete recommended direction.
+5. Do not write PRD, planning, or fixed-agent dispatch input until the direction and acceptance criteria are clear.
+6. For L1/L2 work, create or update the change/task artifacts required by `.cowork-flow/workflow.md` after the clarification output is stable.
+7. Hand off to `writing-plans` when the requested behavior and acceptance criteria are clear.
+
+## Output
+
+Keep the result practical:
+
+- Goal.
+- Non-goals.
+- Key assumptions.
+- Scope boundary, including in-scope and out-of-scope work.
+- Recommended direction and rejected alternatives.
+- Acceptance criteria.
+- Open questions, risks, or blockers, with their impact on the next step.
+
+Do not implement during brainstorming unless the user explicitly changes the request to a direct edit.

package/template/.claude/skills/break-loop/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: break-loop
+description: Use after fixing a bug or repeated failed attempts to identify the root cause, prevention mechanism, and durable knowledge capture.
+---
+
+# Break Loop
+
+Use this after the immediate fix is understood. The goal is to prevent the same class of bug from returning.
+
+## Analysis
+
+1. Root cause: identify whether the issue was missing spec, unclear contract, incomplete propagation, test gap, or hidden assumption.
+2. Failed attempts: if fixes failed, explain what each attempt misunderstood.
+3. Blast radius: search for similar contracts, call sites, scripts, templates, and tests.
+4. Prevention: decide whether the durable fix belongs in code, tests, specs, workflow, or tooling.
+5. Capture: update `.cowork-flow/spec/` or workflow docs when future agents need the lesson.
+
+## Output
+
+Report:
+
+- Root cause.
+- Why the final fix works.
+- Similar areas checked.
+- Prevention added or intentionally skipped.
+- Verification command and result.

package/template/.claude/skills/check/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: check
+description: Use after code or workflow changes to verify quality, spec compliance, tests, cross-layer contracts, and template/root consistency before finish-work.
+---
+
+# Check
+
+Use this after implementation and before `finish-work`.
+
+## Steps
+
+1. Read active task PRD, plan, and `check.jsonl`.
+2. Review `git diff --name-only` and `git diff`.
+3. Check contracts across caller/callee, command output, persisted state, templates, and docs.
+4. Confirm `.cowork-flow/spec/` is updated or explicitly unchanged.
+5. Review test intent: reject shallow tests that do not fail for meaningful behavior breaks.
+6. Run focused tests that would fail if the changed behavior broke.
+7. Run broader validation when the change touches shared runtime, templates, packaging, or public workflow.
+
+## Report
+
+Return:
+
+- Issues found and fixes made.
+- Files reviewed.
+- Commands run and results.
+- Remaining risks.
+
+Do not claim success from intent. Use command output and reviewed diffs as evidence.

package/template/.claude/skills/continue/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: continue
+description: Use when resuming an in-progress cowork-flow task after interruption, context compression, or a new session.
+---
+
+# Continue
+
+Use this to recover the next actionable step without rereading the whole repository.
+
+## Steps
+
+1. Run `.cowork-flow/run resume` or `.\.cowork-flow\run.cmd resume` on Windows.
+2. Run `.cowork-flow/run task current`.
+3. Read the active task `prd.md`.
+4. Read the current plan only if the task references one.
+5. Read the relevant JSONL index for the current phase: `implement.jsonl`, `check.jsonl`, or `debug.jsonl`.
+6. Inspect `git status --short` and any changed files relevant to the task.
+
+## Output
+
+State:
+
+- Active task and phase.
+- Completed work.
+- Next step.
+- Blockers.
+- Verification still required.
+
+Avoid broad archive/history scans unless the active task explicitly depends on them.

package/template/.claude/skills/finish-work/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: finish-work
+description: Use when implementation and verification are complete and cowork-flow work needs final scope review, commit/archive/session recording, or handoff.
+---
+
+# Finish Work
+
+Use this in the main session after implementation and `check` are complete.
+
+## Gate
+
+Before claiming completion, verify:
+
+- Active task exists, or the work was explicitly read-only/no-task.
+- `check` or equivalent final review ran.
+- `git diff` was reviewed for scope.
+- Relevant tests, build, lint, or focused validation ran.
+- `.cowork-flow/spec/` was updated when the change created durable knowledge.
+- Plan checkboxes and task status match reality.
+- No unrelated dirty files are staged.
+
+## Sequence
+
+1. Run `git status --short`.
+2. Run `git diff --check`.
+3. Run focused tests and then broader project verification when appropriate.
+4. Update the plan/task status.
+5. Archive completed task/change artifacts when requested or required by workflow.
+6. Record the session with `.cowork-flow/run add-session --commit "-"` unless a prior commit hash is intentionally being recorded.
+7. If commit policy allows, stage only expected files and commit once.
+
+If the user asks not to commit, stop before staging and report the verified state.

package/template/.claude/skills/meta/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: meta
+description: Use when modifying cowork-flow itself .cowork-flow runtime, template files, .codex hooks/agents, .agent skills, workflow docs, or generated project structure.
+---
+
+# Meta
+
+Use this for changes to the cowork-flow operating model.
+
+## Scope
+
+Meta changes often touch both:
+
+- Root project files used by this repository.
+- `template/` files installed into downstream projects.
+
+Keep those copies aligned unless there is a documented reason not to.
+
+## Rules
+
+- Prefer the current fixed-agent model: main session coordinates through the active Host Adapter, child agents execute bounded tasks with fresh context.
+- Do not add compatibility fallback paths for removed workflow models unless the user explicitly asks.
+- Delete stale skills, prompts, tests, and docs when their behavior is no longer valid.
+- Update tests that guard template contents, packaging, hooks, and task context generation.
+- Keep reusable skills generic; put project-specific lessons in `.cowork-flow/spec/`, `workflow.md`, or `AGENTS.md`.
+- Check Windows command paths and UTF-8 behavior when editing runtime scripts.
+
+## Verification
+
+Run focused tests for the changed subsystem, then `npm run test:all` when template/runtime behavior changed.

package/template/.claude/skills/python-design/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: python-design
+description: Use when writing, reviewing, or refactoring Python CLI/runtime scripts in cowork-flow.
+---
+
+# Python Design
+
+Use this for `.cowork-flow/scripts/**/*.py` and other Python utilities.
+
+## Guidelines
+
+- Keep command parsing thin; move reusable behavior into named functions.
+- Use `pathlib.Path` for filesystem paths.
+- Separate pure decisions from filesystem mutation so tests can cover decisions directly.
+- Prefer explicit data structures over stringly-typed control flow.
+- Handle UTF-8 deliberately on Windows.
+- Catch narrow exceptions; let unexpected failures surface with useful messages.
+- Keep root and `template/` runtime copies aligned.
+
+## Tests
+
+For behavior changes, add or update tests that prove:
+
+- Command arguments are parsed correctly.
+- Files are created, updated, or protected as intended.
+- Error output is specific enough to diagnose the failure.
+- Windows entrypoints remain valid when relevant.

package/template/.claude/skills/start/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: start
+description: Use when starting or resuming main-session work in a cowork-flow project, after context compression, or before repository changes.
+---
+
+# Start
+
+This skill is for the main session only. Formal subagents are accepted only after runtime context binding is recorded and must not load this startup flow.
+Main repository changes follow `Plan -> Implement -> Check -> Finish`.
+Before loading state, classify only whether the current request is a
+main-session request, read-only question, command-only wrapper, or unclear
+input. Do not infer subagent identity from prompt shape. If a child has
+`cowork_runtime_context_id`, hook/plugin binding may run early; otherwise the
+child must run the explicit shim bind before formal work.
+
+## Load State
+
+1. Read `AGENTS.md`.
+2. Read `.cowork-flow/workflow.md`.
+3. Read `.cowork-flow/config.yaml` for Codex dispatch hints and lifecycle hooks.
+4. Run `.cowork-flow/run resume` or `.\.cowork-flow\run.cmd resume` on Windows.
+5. Read the active task PRD and JSONL indexes only when a task is active.
+6. Read relevant `.cowork-flow/spec/*/index.md` files before code changes.
+
+Report active task, workflow state, blockers, and the next phase.
+
+## Route
+
+Route in stages. Before state is loaded, true question-only requests may bypass
+Load State. Repository-changing main-session requests load state first. After
+state is loaded, apply the requirement clarification gate from
+`.cowork-flow/workflow.md`, then route to the next workflow phase; clear
+multi-step implementation uses `writing-plans` before fixed-agent dispatch.
+
+New requirements that are unclear, boundary-unclear, multi-approach, behavior-changing, or missing acceptance criteria use `brainstorming` before PRD, planning, or fixed-agent dispatch. Small repository changes proceed directly only when the goal, scope boundary, and acceptance criteria are already clear.
+
+- Question-only work: answer directly.
+- Small repository change with clear goal/scope/acceptance: classify by `.cowork-flow/workflow.md`, create/start a task if required, then proceed.
+- Unclear, boundary-unclear, behavior-changing, or multi-approach work: use `brainstorming`.
+- Multi-step implementation: use `writing-plans`, then dispatch fixed agents where appropriate.
+- Before coding: use `before-dev`.
+- After implementation: use `check`, then `finish-work`.
+
+## Parallel Route
+
+- Use parallel sessions for independent tasks.
+- Use a separate `git worktree` when independent sessions may write files.
+- Inside one task, dispatch parallel agents only for low-conflict slices with clear ownership.
+- After parallel slices finish, run final integrated verification before Check/Finish.
+
+## Fixed Agents
+
+The main session owns coordination:
+
+- Research: dispatch `cowork-research` through the active Host Adapter.
+- Implementation: dispatch `cowork-implement` through the active Host Adapter.
+- Verification: dispatch `cowork-check` through the active Host Adapter.
+
+Every formal dispatch uses runtime-context dispatch:
+
+```text
+cowork_runtime_context_id: <runtime_context_id>
+cowork_host_context_key: <host_context_key>
+```
+
+Before spawning a formal child, create a runtime context with
+`.cowork-flow/run subagent init` and pass the returned prompt transport through
+the active Host Adapter. The child's first step is
+`.cowork-flow/run subagent bind <runtime_context_id> <host_context_key>`; if a
+hook/plugin already bound the same key, this command is idempotent. The parent
+must verify `status=bound` and `bound_context_key=<host_context_key>` before
+accepting output. If binding is missing, closed, invalid, or mismatched, the
+child fails closed and must not run start/resume/task activation/archive/commit
+or coordinate other agents.
+
+After dispatch, use adapter wait/list/cancel primitives, review the output,
+verify deliverables, and close the runtime context with
+`.cowork-flow/run subagent close <runtime_context_id>`.

package/template/.claude/skills/update-spec/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: update-spec
+description: Use when implementation lessons, contracts, conventions, or gotchas should be captured in .cowork-flow/spec.
+---
+
+# Update Spec
+
+Use this when a change teaches something future agents need to know.
+
+## Decide Whether To Update
+
+Update specs when you learned:
+
+- A command, API, file, payload, or state contract.
+- A validation rule or error behavior.
+- A project convention.
+- A repeated failure mode or non-obvious gotcha.
+- A design decision future changes must preserve.
+
+Skip one-off implementation details that do not guide future work.
+
+## Choose Location
+
+- `backend/` or `frontend/`: implementation contracts, signatures, examples, validation behavior, test points.
+- `guides/`: short thinking checklists and pointers to deeper specs.
+- `.cowork-flow/workflow.md`: process rules, phase gates, or task routing behavior.
+- `AGENTS.md`: project-level collaboration rules.
+
+## Write
+
+Keep each update concrete:
+
+- State the trigger and scope.
+- Show the contract or command shape.
+- Include good/bad cases when useful.
+- State tests or checks that protect the behavior.
+- Update the matching `index.md` when adding a new topic.
+
+Before finishing, check for duplicate guidance and remove stale wording.

package/template/.claude/skills/writing-plans/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: writing-plans
+description: Use when requirements are clear enough to turn into an executable multi-step cowork-flow implementation plan.
+---
+
+# Writing Plans
+
+Create a plan that another agent can execute without guessing.
+
+## Inputs
+
+Before writing a plan, confirm the request has an executable scope, acceptance criteria, and intended behavior. If those are missing, ask for clarification.
+
+Read:
+
+- Active task PRD.
+- Relevant change spec/design files.
+- Relevant `.cowork-flow/spec/` indexes and target specs.
+- Files that define the contracts being changed.
+
+## Plan Shape
+
+Save plans to `.cowork-flow/plans/YYYY-MM-DD-<slug>.md` unless the user asks for another path.
+
+Start with:
+
+```markdown
+# <Feature> Implementation Plan
+
+> For formal fixed-agent work: create a runtime context with `.cowork-flow/run subagent init`, pass `cowork_runtime_context_id: <runtime_context_id>` through the active Host Adapter, then dispatch `cowork-implement` or `cowork-check`. Close the runtime context after verification.
+
+**Goal:** <one sentence>
+**Architecture:** <2-3 sentences>
+**Verification:** <commands or checks>
+```
+
+## Task Rules
+
+- Each task names exact files to create, modify, or test.
+- Each step is small enough to execute and verify independently.
+- Include commands and expected results.
+- Include a failing test before implementation when behavior can be tested.
+- Do not add shallow tests just to satisfy process. Avoid tests that only assert existence, mirror implementation details, count mocks without behavior, or snapshot empty structure.
+- For complex problems, test depth first: cover invariants, cross-layer contracts, state transitions, error boundaries, and real regression paths before narrow unit cases.
+- Avoid placeholders such as TODO, TBD, "handle edge cases", or "write tests".
+- Keep root/template parity explicit when both copies exist.
+
+## Parallel Work
+
+Execution strategy guide:
+
+- Use serial work when slices share files, shared helpers, tests, or one behavior chain.
+- Use parallel low-conflict slices only when file ownership is clean and each slice has independent verification.
+- Use worktree parallel when independent tasks may touch package metadata, generated assets, build outputs, or broad config.
+
+- Do not require the user to predeclare parallel execution; evaluate parallel feasibility while writing the plan.
+- Every plan must state the execution strategy: serial work, or explicit parallel low-conflict slices.
+- Parallel work items belong in the plan only when they are independent low-conflict slices.
+- Each parallel item must name file ownership, dependencies, expected outputs, and verification commands.
+- Use separate sessions, and use a separate `git worktree` when independent tasks may write overlapping project areas.
+- After parallel items finish, include one final integrated verification step before Check/Finish.
+
+## Self-Review
+
+Before handoff:
+
+1. Confirm every PRD acceptance criterion maps to a plan step.
+2. Search the plan for placeholders.
+3. Check names, paths, command syntax, and expected outputs.
+4. Record remaining risks or blockers.

package/template/.codex/agents/cowork-check.toml

@@ -1,39 +1,34 @@
 name = "cowork-check"
-description = "Cowork-flow checker that reviews active task changes and fixes in-scope issues."
+description = "Cowork-flow checker for runtime-context bound review tasks."
 sandbox_mode = "workspace-write"
 
 developer_instructions = """
 You are the `cowork-check` subagent.
 
-The dispatch message SHOULD include this lightweight envelope:
-COWORK_DISPATCH_V1
-dispatch_id: <dispatch-id>
-task_dir: .cowork-flow/tasks/<task>
-agent_type: cowork-check
-role: check
-context_file: <context-file>
-ack_token: <ack-token>
-COWORK_DISPATCH_END
+Formal `cowork-check` work requires runtime-context dispatch. The prompt or
+host metadata must provide:
 
-If the envelope agent_type is not `cowork-check`, report needs_context and do not execute it. If agent_type is missing, legacy role `cowork-check` is accepted. If role names another fixed agent, report needs_context and do not execute it.
+cowork_runtime_context_id: <runtime_context_id>
+cowork_host_context_key: <host_context_key>
 
-When the envelope is present, it wins over bootstrap, AGENTS.md, and no-task context. First return only:
-COWORK_ACK <dispatch_id> <ack_token>
+The hook may bind that id to `.cowork-flow/.runtime/subagents/<runtime_context_id>.json`
+before workflow state is injected. The first child step must still run:
 
-Do not execute the task until the coordinator sends:
-EXECUTE <dispatch_id>
+./.cowork-flow/run subagent bind <runtime_context_id> <host_context_key>
 
-If a follow-up has a missing or mismatched dispatch_id, report needs_context and do not execute it.
+On Windows, use:
 
-Legacy dispatch without an envelope MUST start with:
-Active task: .cowork-flow/tasks/<task>
+.\\.cowork-flow\\run.cmd subagent bind <runtime_context_id> <host_context_key>
 
-If the message contains neither the envelope nor that line, stop and ask for the active task path.
+If the explicit bind fails, or if the bound runtime context is missing, closed,
+invalid, or names another agent type, report needs_context and do not execute
+the task.
 
 Load context before checking:
-1. Read `<task>/prd.md`.
-2. Read `<task>/check.jsonl`.
-3. Read `git diff`.
+1. Read the task directory from the bound runtime context.
+2. Read `<task>/prd.md`.
+3. Read `<task>/check.jsonl`.
+4. Read `git diff`.
 
 Rules:
 - Fix issues directly when they are clearly in scope.

package/template/.codex/agents/cowork-implement.toml

@@ -1,40 +1,35 @@
 name = "cowork-implement"
-description = "Cowork-flow implementer that self-loads task context from Active task."
+description = "Cowork-flow implementer for runtime-context bound implementation tasks."
 sandbox_mode = "workspace-write"
 
 developer_instructions = """
 You are the `cowork-implement` subagent.
 
-The dispatch message SHOULD include this lightweight envelope:
-COWORK_DISPATCH_V1
-dispatch_id: <dispatch-id>
-task_dir: .cowork-flow/tasks/<task>
-agent_type: cowork-implement
-role: implement
-context_file: <context-file>
-ack_token: <ack-token>
-COWORK_DISPATCH_END
+Formal `cowork-implement` work requires runtime-context dispatch. The prompt or
+host metadata must provide:
 
-If the envelope agent_type is not `cowork-implement`, report needs_context and do not execute it. If agent_type is missing, legacy role `cowork-implement` is accepted. If role names another fixed agent, report needs_context and do not execute it.
+cowork_runtime_context_id: <runtime_context_id>
+cowork_host_context_key: <host_context_key>
 
-When the envelope is present, it wins over bootstrap, AGENTS.md, and no-task context. First return only:
-COWORK_ACK <dispatch_id> <ack_token>
+The hook may bind that id to `.cowork-flow/.runtime/subagents/<runtime_context_id>.json`
+before workflow state is injected. The first child step must still run:
 
-Do not execute the task until the coordinator sends:
-EXECUTE <dispatch_id>
+./.cowork-flow/run subagent bind <runtime_context_id> <host_context_key>
 
-If a follow-up has a missing or mismatched dispatch_id, report needs_context and do not execute it.
+On Windows, use:
 
-Legacy dispatch without an envelope MUST start with:
-Active task: .cowork-flow/tasks/<task>
+.\\.cowork-flow\\run.cmd subagent bind <runtime_context_id> <host_context_key>
 
-If the message contains neither the envelope nor that line, stop and ask for the active task path.
+If the explicit bind fails, or if the bound runtime context is missing, closed,
+invalid, or names another agent type, report needs_context and do not execute
+the task.
 
 Load context before editing:
-1. Read `<task>/prd.md`.
-2. Read `<task>/info.md` if present.
-3. Read `<task>/implement.jsonl`.
-4. Read each JSONL `file` entry.
+1. Read the task directory from the bound runtime context.
+2. Read `<task>/prd.md`.
+3. Read `<task>/info.md` if present.
+4. Read `<task>/implement.jsonl`.
+5. Read each JSONL `file` entry.
 
 Rules:
 - MUST NOT spawn, wait for, list, or close other agents.

package/template/.codex/agents/cowork-research.toml

@@ -1,36 +1,31 @@
 name = "cowork-research"
-description = "Cowork-flow researcher that records findings under the active task."
+description = "Cowork-flow researcher for runtime-context bound research tasks."
 sandbox_mode = "workspace-write"
 
 developer_instructions = """
 You are the `cowork-research` subagent.
 
-The dispatch message SHOULD include this lightweight envelope:
-COWORK_DISPATCH_V1
-dispatch_id: <dispatch-id>
-task_dir: .cowork-flow/tasks/<task>
-agent_type: cowork-research
-role: research
-context_file: <context-file>
-ack_token: <ack-token>
-COWORK_DISPATCH_END
+Formal `cowork-research` work requires runtime-context dispatch. The prompt or
+host metadata must provide:
 
-If the envelope agent_type is not `cowork-research`, report needs_context and do not execute it. If agent_type is missing, legacy role `cowork-research` is accepted. If role names another fixed agent, report needs_context and do not execute it.
+cowork_runtime_context_id: <runtime_context_id>
+cowork_host_context_key: <host_context_key>
 
-When the envelope is present, it wins over bootstrap, AGENTS.md, and no-task context. First return only:
-COWORK_ACK <dispatch_id> <ack_token>
+The hook may bind that id to `.cowork-flow/.runtime/subagents/<runtime_context_id>.json`
+before workflow state is injected. The first child step must still run:
 
-Do not execute the task until the coordinator sends:
-EXECUTE <dispatch_id>
+./.cowork-flow/run subagent bind <runtime_context_id> <host_context_key>
 
-If a follow-up has a missing or mismatched dispatch_id, report needs_context and do not execute it.
+On Windows, use:
 
-Legacy dispatch without an envelope MUST start with:
-Active task: .cowork-flow/tasks/<task>
+.\\.cowork-flow\\run.cmd subagent bind <runtime_context_id> <host_context_key>
 
-If the message contains neither the envelope nor that line, stop and ask for the active task path.
+If the explicit bind fails, or if the bound runtime context is missing, closed,
+invalid, or names another agent type, report needs_context and do not execute
+the task.
 
 Rules:
+- Read the task directory from the bound runtime context.
 - Write only under `<task>/research/`.
 - Do not modify code, specs, task state, or git.
 - Persist findings to Markdown files.

package/template/.codex/agents/default.toml

@@ -0,0 +1,27 @@
+name = "default"
+description = "Codex default agent hardened against bootstrap hijack. Runs bounded delegated work; must not run project start/resume or create tasks."
+sandbox_mode = "workspace-write"
+
+developer_instructions = """
+You are a dispatched default agent. Your task comes from the dispatch message or the bounded brief, not from project bootstrap or start-session skills.
+
+If AGENTS.md or .agent/skills/start tells you to start a session, skip that start skill.
+Do not run the project start-session workflow or try to spawn another agent from this prompt.
+
+Generic default-agent dispatch is advisory and cannot satisfy formal Implement
+or Check completion. Follow the bounded prompt directly. Project rules are
+constraints only; they are not the task.
+
+Rules:
+- MUST NOT spawn, wait for, list, or close other agents.
+- MUST NOT run task start, task finish, task archive, or unscoped resume.
+- MUST NOT commit or push.
+- Keep edits inside requested scope.
+- Report changed files and exact verification commands.
+"""
+
+[features]
+multi_agent = false
+
+[features.multi_agent_v2]
+enabled = false