# Operation boundaries

Keep explicit authorization and backup for live databases, destructive
changes, deployment, publication and security-sensitive operations. A request
for implementation is not permission for unrelated production changes.
Distinguish editing a migration source from executing it on a live database.

Work solo unless delegation was specifically approved. Workers never approve
other workers. Read-only tools are preferred for investigation. Use the
smallest meaningful runtime check for code; no automatic validation of prose.

One owner handles shared build resources. Inspect real command effects.
Timeouts do not prove child exit. Runtime permissions and approval policies
remain owned by the active harness.

# ship usage

/ship <clear request>
/ship <brief-folder or PROPOSAL.md>
/ship -r <artifact>
/ship --tasks T01-T04 <artifact>

Solo and no commits are defaults. --commit requests immediate green commits
per coherent unit. --no-commit disables them. -e/-m solo forbid delegation;
other modes still require explicit agent consent. -a skips redundant
questions, never safety or agent permission. --yolo requests relevant safe
checks, not live-data changes or deployment.

On OMP and Pi, /arsenal-mode on routes every request through Arsenal without
changing native tools or permissions. /arsenal-mode off returns to native
behavior, and /arsenal-mode status shows the current state.

# Bounded worker contract

Load only after user approval. Supply: absolute root, exact question/outcome,
authorized files, relevant source excerpts, fixed interfaces and evidence
required. Do not paste the full session or rediscover the whole repository.

All roles: respect user stop requests, no nested agents/advisors, no Git
operations, no live data changes, no compiler jobs, no configuration changes.
Use native tools and absolute paths. Return one concise report with concrete
file/line evidence, changed files, uncertainty and blockers. No progress spam.

- Implementer: change only the assigned independent unit. Return ready for
  integration; the lead proves and optionally commits it.
- Reviewer: read only the designated risk boundary. Return substantiated
  defects, or an empty result. Do not fill a finding quota.

Use existing native agent profiles when they match. Missing capability or
invalid output is handled once by the lead, not by another agent tree.

#!/usr/bin/env bash
set -euo pipefail
dir="${1:-$PWD}"
pm="unknown"; lang="unknown"
if   [ -f "$dir/pnpm-lock.yaml" ];   then pm="pnpm";    lang="js"
elif [ -f "$dir/bun.lockb" ] || [ -f "$dir/bun.lock" ]; then pm="bun"; lang="js"
elif [ -f "$dir/yarn.lock" ];        then pm="yarn";    lang="js"
elif [ -f "$dir/package-lock.json" ];then pm="npm";     lang="js"
elif [ -f "$dir/Cargo.toml" ];       then pm="cargo";   lang="rust"
elif [ -f "$dir/go.mod" ];           then pm="go";      lang="go"
elif [ -f "$dir/uv.lock" ];          then pm="uv";      lang="python"
elif [ -f "$dir/pyproject.toml" ];   then pm="poetry";  lang="python"
elif [ -f "$dir/requirements.txt" ]; then pm="pip";     lang="python"
elif [ -f "$dir/Gemfile" ];          then pm="bundler"; lang="ruby"
elif [ -f "$dir/pom.xml" ];          then pm="maven";   lang="jvm"
elif [ -f "$dir/build.gradle" ] || [ -f "$dir/build.gradle.kts" ]; then pm="gradle"; lang="jvm"
elif [ -f "$dir/composer.json" ];    then pm="composer";lang="php"
fi
printf '{"language":"%s","package_manager":"%s"}\n' "$lang" "$pm"

#!/usr/bin/env bash
set -euo pipefail
out="${1:?usage: scaffold.sh <output_dir>}"
here="$(cd "$(dirname "$0")/.." && pwd)"
mkdir -p "$out"
for t in contract verification-bundle trace; do
  if [ -f "$out/$t.md" ]; then
    echo "skip (exists): $out/$t.md"
  else
    cp "$here/templates/$t.md" "$out/$t.md"
    echo "created: $out/$t.md"
  fi
done

# Resume and scope

Read the exact requested artifact and its existing trace once. Restore the
root, completed units, current work and outstanding permissions. Do not
re-run completed units. A terminal trace or shipped marker means done.

Defaults: solo, no commits, no extra reviewers, no full suite. Ask only for
a blocking missing decision. Use absolute target paths, never the Eval cwd.
For multi-session work, keep one trace.md beside the spec. Inline work needs
no durable files unless requested. A native todo mirrors this progress.

If a command is still running, recover its job instead of starting another.
The OMP controller status is authoritative for its processes and execution
evidence; the trace stores task intent and cross-session acceptance status.

# Input routing

Help loads references/help-text.md and stops. A clear request runs directly.
A brief folder or PROPOSAL.md uses step-01-ingest.md. An ambiguous path is
resolved from existing files before asking. Never require a brief for a fix.
If a brief points to its accepted proposal, execute the proposal once, not
both artifacts. Auto mode does not authorize agents or hazardous actions.

# Read an approved specification

Brief: read brief.md status ready, acceptance criteria and tasks.md.
Proposal: read PROPOSAL.md status Accepted, design and section 10 tasks.
Do not infer acceptance from the act of writing a proposal. Check for the
sibling PROPOSAL.shipped marker first.

Apply --tasks only to named tasks and already-satisfied dependencies. Keep
source task identifiers. Ask only about questions that block implementation.
Do not invent requirements or re-author an approved design. Read actual
project commands from manifests or Makefile; stack detection is a hint, not
a substitute for reading effects such as install/deploy.

# Plan only the necessary dependencies

For complex work, order existing tasks by dependency. File separation alone
does not establish independence: account for shared APIs, data and build
resources. One lead owns integration and compilations. Do not add a DAG or
a confirmation gate to a small fix.

Commits are optional and require the user delivery workflow. If requested,
commit each coherent unit immediately after its targeted green check, before
starting the next unit. Preserve the existing green-commit discipline: no
unchecked commits, no catch-all final commit, no unrelated staged changes.
Use the project Git/Graphite conventions and preserve unrelated dirty work.
No permission-grant file or push is inferred from a branch choice.

# Delegation is an explicit exception

Default: the lead works solo, including verification. -e and -m solo mean
no workers or reviewers. Never launch an advisor in their place.

Before any other mode, explain the independent units and the expected benefit
over doing them directly. Ask for approval. -a, --auto and --yolo do not
grant it. Without approval or runtime capability, continue solo.

After approval, use the active harness native agent API, at most three bounded
workers, no nested delegation. Do not request bypassPermissions or retune
models. Read references/role-templates.md only when actually delegating.
Do useful non-overlapping work while workers run; collect each result once.

# Execute and prove

Read relevant code, fix only the requested behavior, preserve unrelated work.
Use native editing tools and explicit target paths. Do not assume a JS or
Python kernel shares the shell working directory.

Run the smallest real check after the change. One owner runs compiler/check
commands; workers return patches and evidence, never competing builds.
Never repeat a passing check without a relevant change. A timeout requires
job inspection, not duplicate execution. Stop retrying without new evidence.

Record completed work immediately in the existing task ledger. Separate
implemented, checked and awaiting-user-acceptance states. If green commits
were requested, commit the unit now; otherwise leave the changes uncommitted.

# Verification without extra agents

The lead verifies. No mandatory creator-verifier, read-back of every file,
full suite, new tests, or model session. Reuse evidence already obtained.

Prose/simple configuration: successful edit unless the user asked to check.
Behavioral change: execute the relevant existing command or disposable smoke
scenario. A meaningful command, not an arbitrary zero exit, proves behavior.
Data migration: backup and real-copy checks remain required. Ask before
permanent tests or live-data changes.

Under the OMP controller, use bash verification:true for the relevant final
check and arsenal_finish when complete. Report unavailable native/UI/network
capabilities honestly. A saved bundle is optional; do not make the user rerun
checks that you already executed successfully.

# Finish once

Close completed native todo items immediately. Keep external acceptance
blocked separately. Report the result and exact evidence, not workflow steps.
Never continue canceled work due to a reminder.

If using durable artifacts: update trace rows; reconcile completed brief
checkboxes and mark the brief shipped only when its entire scope is complete.
For a fully completed proposal, write PROPOSAL.shipped and leave the accepted
proposal unchanged. A scoped run does not close unfinished sibling work.

No mandatory HTML, extra report, fresh agent, final catch-all commit or PR
offer. Publish/push/create a PR only after explicit authorization. Preserve
a declined/deferred Git decision. Stop approved workers through the native
harness; do not delete unrelated team/session files.

# Acceptance criteria

Use only when a durable contract was requested. Reference the source spec
rather than copying it. Record the scope, non-goals and observable outcome.

artifact_path: null
project_root: null
run_id: ""
task_filter: null
engine_tier: solo
commit_mode: false
work_branch: null
stepsCompleted: []
final_status: in_progress
tasks: []

---
artifact: ""
project_root: ""
run_id: ""
task_filter: null
engine_tier: solo
commit_mode: false
work_branch: null
stepsCompleted: []
final_status: in_progress
---

# Progress

| Unit | Status | Files | Evidence | Commit if requested |
|---|---|---|---|---|

## Remaining decisions

# Verification

Create only when requested or for checks unavailable to the agent.

| Criterion | Command or manual action | Expected result | Observed result |
|---|---|---|---|

Separate pending user acceptance from checks already executed successfully.