duaer-spec 0.2.0 → 0.3.0

package/.cursor/rules/duaer-spec.mdc

@@ -1,16 +1,32 @@
 ---
-description: Features and hotfixes must go through Duaer; no code from verbal asks alone
+description: Features and hotfixes must go through Duaer; job handoff before claiming done
 alwaysApply: true
 ---
 
 # Duaer required (NON-NEGOTIABLE)
 
-Treat agents as digital employees: assign a Brief (Spec) before code; accept
-only via converge. See `DUADER.md` and `.duaer/memory/constitution.md`.
+Treat agents as **digital employees**: assign a Brief (Spec) before code; accept
+via converge; only then claim the **job** is done. See `DUADER.md` and
+`.duaer/memory/constitution.md`.
 
 If this rule conflicts with root `AGENTS.md` / `docs/agent/` (worktrees, commits,
 Issue/PR), **AGENTS.md wins**.
 
+## Handoff policy (job-level, not a repo lock)
+
+Read `.duaer/delivery-policy.json` (`off` | `coach` | `strict`, default **coach**).
+
+- This controls whether you may **report the active job complete** — not whether
+  git may commit or merge.
+- Active job: `.duaer/active-job.json` → `feature`, else the latest `.duaer/specs/*`.
+- Check with `duaer job .` before telling the user work is finished.
+
+| Mode | Agent behavior when active job is not accepted |
+|---|---|
+| `off` | May continue; do not invent an accept stamp |
+| `coach` | Warn; guide to specify / tasks / converge; **do not say "done"** |
+| `strict` | **Refuse** to report delivery complete until `duaer job` shows accepted |
+
 ## When Duaer is mandatory
 
 Always write/update a feature spec (Brief) before coding for:
@@ -23,7 +39,7 @@ Forbidden: jump from chat to code with no `spec.md` / feature directory under `.
 
 ## Default flow
 
-`/duaer-specify` → `/duaer-plan` → `/duaer-tasks` → `/duaer-implement` → `/duaer-converge`
+`/duaer-specify` → `/duaer-plan` → `/duaer-tasks` → `/duaer-implement` → `/duaer-converge` → `duaer job`
 
 ## Hotfix (still Spec, shortened)
 
@@ -31,5 +47,5 @@ Forbidden: jump from chat to code with no `spec.md` / feature directory under `.
 
 - Implement only from `tasks.md` when it exists
 - Update `.duaer/memory/project-context.md` when architecture changes
-- Run the verification named in the feature docs before merge
-- Before merge: `duaer check . --gate` (Spec present, no open tasks, `delivery.json` accepted)
+- Run the verification named in the feature docs
+- Before claiming done: `duaer job .` shows accepted (coach/strict)

package/.cursor/skills/duaer-converge/SKILL.md

@@ -265,15 +265,18 @@ Append to the **end** of `tasks.md`, per the append contract:
   path instead — do not stamp accepted).
 - Report: **"✅ Converged — the implementation satisfies the spec, plan, and tasks."**
 - Include the summary counts of what was checked.
-- Tell the user they can run `duaer check . --gate` to verify the machine gate.
+- Tell the user they can run `duaer job .` to see handoff status (policy default: coach).
+- Reminder: this is **job acceptance**, not a repository merge lock.
 ### 8. Provide Next Actions (Handoff)
 
 - On `tasks_appended`: state how many tasks were appended under which phase, and recommend
   running `/duaer-implement` to complete them; note that a follow-up converge
   run will find fewer or no remaining items. Remind: `delivery.json` is `open` —
-  `duaer check --gate` will fail until accepted.
-- On `converged`: recommend `duaer check . --gate`, then review / opening a PR. No further
-  implement pass is needed for this feature's specified scope.
+  under coach/strict, do **not** claim the job is done; `duaer job .` will show unfinished.
+- On `converged`: recommend `duaer job .`, then ask the user to review. No further
+  implement pass is needed for this feature's specified scope. Use the handoff script:
+  "✅ Job accepted — Brief satisfied per converge; ready for your review."
+  Do not frame this as a git/CI merge requirement.
 
 ### 9. Check for extension hooks
 

package/.cursor/skills/duaer-specify/SKILL.md

@@ -104,11 +104,23 @@ Given that feature description, do this:
      Write the actual resolved directory path value (for example, `specs/003-user-auth`), not the literal string `SPECIFY_FEATURE_DIRECTORY`.
      This allows downstream commands (`/duaer-plan`, `/duaer-tasks`, etc.) to locate the feature directory without relying on git branch name conventions.
 
+   - Also write / overwrite `.duaer/active-job.json` (job handoff pointer):
+     ```json
+     {
+       "schemaVersion": 1,
+       "feature": "<directory-name only, e.g. 003-user-auth>",
+       "featureDirectory": "<resolved feature dir>",
+       "updatedAt": "<ISO-8601 UTC>",
+       "source": "duaer-specify"
+     }
+     ```
+     `feature` is the basename under `.duaer/specs/` (or `specs/`) that `duaer job` resolves.
+
    **IMPORTANT**:
    - You must only create one feature per `/duaer-specify` invocation
    - The spec directory name and the git branch name are independent — they may be the same but that is the user's choice
    - The spec directory and file are always created by this command, never by the hook
-
+   - Setting `active-job.json` makes this the job the employee must hand off; it does **not** lock git
 4. Load the resolved active `spec-template` file to understand required sections.
 
 5. **IF EXISTS**: Load `.duaer/memory/constitution.md` for project principles and governance constraints.

package/.duaer/delivery-policy.json

@@ -0,0 +1,6 @@
+{
+  "schemaVersion": 1,
+  "mode": "coach",
+  "scope": "active",
+  "notes": "Job-level handoff. off=record only; coach=guide (default); strict=do not claim done until accepted. Not a git merge lock."
+}

package/.duaer/memory/constitution.md

@@ -36,7 +36,13 @@ Do not expand scope without updating the spec and tasks.
 Mark tasks complete only when the stated verification (tests, manual checks,
 or converge) has been performed or explicitly waived in the feature docs.
 
-Before merge, run `duaer check . --gate`. It fails on missing Spec, open
-`- [ ]` tasks, or `delivery.json` that is not `status: "accepted"`. Converge
-assessment is still agent-assisted; the gate makes the **handoff state**
-machine-checkable.
+**Job handoff (not a git lock):** before telling the user the work is finished,
+run `duaer job .`. Read `.duaer/delivery-policy.json`:
+
+- `coach` (default): if the active job is not `accepted`, warn and guide — do
+  **not** claim "done"
+- `strict`: refuse to report delivery complete until accepted
+- `off`: record only
+
+Converge still stamps `delivery.json`. Judgment Spec↔code remains
+agent-assisted; the stamp makes the **job** checkable.

package/ADOPT.md

@@ -1,7 +1,7 @@
 # Adopt duaer-spec
 
-Onboard a **digital employee** into another repository: install the Duaer
-delivery OS (method) and the agent-ops contract (how they are allowed to work).
+Onboard a **digital employee**: install the Duaer delivery OS (method) and the
+agent-ops contract. Controllability is **job handoff**, not a git merge lock.
 
 ## Recommended: CLI
 
@@ -11,7 +11,7 @@ From the target project (Node 18+):
 npx duaer-spec init --here
 
 # Pin a release
-npx github:fujiezee/duaer-spec@v0.2.0 duaer init --here
+npx github:fujiezee/duaer-spec@v0.3.0 duaer init --here
 
 # Lite (method only) / ops only / other integration branch
 npx duaer-spec init --here --method
@@ -22,7 +22,8 @@ From a clone of this repo:
 
 ```bash
 node bin/duaer.mjs init /path/to/project --all
-node bin/duaer.mjs check /path/to/project
+node bin/duaer.mjs job /path/to/project
+node bin/duaer.mjs policy /path/to/project
 ```
 
 `--force` overwrites managed files.
@@ -30,11 +31,11 @@ node bin/duaer.mjs check /path/to/project
 Then:
 
 1. **Orient** — edit `.duaer/memory/constitution.md` and `project-context.md`
-2. **Confirm workplace** — `docs/baseline.md` (integration branch)
-3. **Assign → work → accept → gate** — `/duaer-specify` → `/duaer-plan` → `/duaer-tasks` → `/duaer-implement` → `/duaer-converge` → `duaer check . --gate`
+2. **Policy** — `duaer policy .` (default `coach`; optional `off` | `strict`)
+3. **Assign → work → accept → handoff** — `/duaer-specify` → … → `/duaer-converge` → `duaer job .`
 
-A job without Spec is not assigned. Open tasks or a non-`accepted` `delivery.json`
-is not accepted. `duaer check --gate` is the machine merge check.
+A job without Spec is not assigned. An unaccepted active job must not be reported
+as done under `coach`/`strict`. Git is not blocked by default.
 
 ## Manual copy (optional)
 

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.3.0 — 2026-09-15
+
+### Job handoff (not a repo lock)
+
+- Default policy **`coach`**: guide the employee; do not claim "done" until the
+  **active job** is accepted — git merge is not blocked
+- `.duaer/delivery-policy.json` modes: `off` | `coach` | `strict`
+- `.duaer/active-job.json` set by `/duaer-specify`; `duaer job` reports status
+- `duaer policy` to show/set mode
+- `duaer check` defaults to active-job scope; `--strict` / policy `strict` optional
+- `--gate` kept as deprecated alias for `--strict` (job handoff, not CI)
+- `--all-jobs` optional; historical features no longer fail the default path
+- Docs/rules/constitution demote merge-gate language
+
+### E2E
+
+- E2E-004–007 for coach default, strict optional, active-job scope
+
 ## 0.2.0 — 2026-09-15
 
 ### Controllable delivery (machine gate)
@@ -46,9 +64,6 @@ First public methodology release.
 ### Install
 
 ```bash
-# From GitHub (works now)
 npx github:fujiezee/duaer-spec@v0.1.0 duaer init --here
-
-# From npm (after publish)
 npx duaer-spec init --here
 ```

package/DUADER.md

@@ -1,59 +1,64 @@
 # Duaer methodology
 
 **duaer-spec** owns this method. Treat AI coding agents as **digital employees**:
-you assign a Brief (Spec), they follow a fixed work order, and delivery only
-counts after **converge** accepts the result against that Brief.
+you assign a Brief (Spec), they follow a fixed work order, and the **job** only
+counts as done after **converge** accepts it — then `duaer job` shows accepted.
 
 Artifacts live under `.duaer/`; Cursor skills are `duaer-*` at `.cursor/skills/`.
 
 **Precedence:** root [`AGENTS.md`](AGENTS.md) / [`docs/agent/`](docs/agent/) win
 over anything here for isolation, commits, and Issue/PR gates.
 
+**Handoff is job-level**, not a repository merge lock. Policy:
+`.duaer/delivery-policy.json` (`off` | `coach` | `strict`, default `coach`).
+
 ## Read before work
 
 1. `.duaer/memory/constitution.md` — process principles
 2. `.duaer/memory/project-context.md` — as-is implementation truth
 3. `.duaer/memory/testing.md` — verification expectations
-4. Active feature under `.duaer/specs/<nnn-slug>/` when one exists
+4. Active job: `.duaer/active-job.json` → feature under `.duaer/specs/<nnn-slug>/`
 
 ## Standard path
 
 **Full (recommended):**
 
 1. `/duaer-constitution` — only when principles change
-2. `/duaer-specify` — **Assign**: what / why / acceptance (not stack trivia)
+2. `/duaer-specify` — **Assign**: Brief + set `active-job.json`
 3. `/duaer-clarify` — optional
 4. `/duaer-plan` — technical plan aligned with project-context
 5. `/duaer-checklist` — optional quality checklist
 6. `/duaer-tasks` — checkbox task breakdown
 7. `/duaer-analyze` — optional consistency check
 8. `/duaer-implement` — implement tasks only
-9. `/duaer-converge` — **Accept**: compare result to Spec; write `delivery.json`; append remaining tasks if gaps
-10. `duaer check . --gate` — **Gate**: fail merge if Spec missing, tasks open, or stamp not accepted
+9. `/duaer-converge` — **Accept**: compare to Spec; write `delivery.json`
+10. `duaer job .` — **Handoff**: may this job be reported done?
 
-**Small feature:** specify → plan → tasks → implement → converge → `check --gate`  
+**Small feature:** specify → plan → tasks → implement → converge → `duaer job`  
 
-**Hotfix:** specify (mark hotfix) → tasks → implement → converge → `check --gate`  
-Never skip specify (assign), converge (accept), or the gate.
+**Hotfix:** specify (mark hotfix) → tasks → implement → converge → `duaer job`  
+Never skip specify (assign) or converge (accept). Under coach/strict, never claim
+"done" while `duaer job` is unfinished.
 
 ## Install
 
 ```bash
 npx duaer-spec init --here
+duaer policy . coach
 ```
 
-Or see [`ADOPT.md`](ADOPT.md). No third-party Spec CLI is required — `duaer`
-installs this repository's method files into the target project.
+Or see [`ADOPT.md`](ADOPT.md).
 
 ## Feature directory shape
 
 ```text
+.duaer/delivery-policy.json
+.duaer/active-job.json
 .duaer/specs/<nnn-slug>/
   spec.md         # Brief
-  plan.md         # after /duaer-plan
-  tasks.md        # after /duaer-tasks
-  delivery.json   # after /duaer-converge (accepted | open)
-  …               # research / contracts as needed
+  plan.md
+  tasks.md
+  delivery.json   # accepted | open
 ```
 
 ## Related

package/README.md

@@ -3,100 +3,83 @@
 **Duaer** is a delivery operating system for AI coding agents treated as
 **digital employees**.
 
-Agents write the code. Duaer makes the **handoff controllable**: every job has a
-Brief (Spec), follows a fixed work order, and only counts as done when the
-**delivery gate** passes — not after a lucky chat.
+Agents write the code. Duaer makes the **job handoff controllable**: every job
+has a Brief (Spec), follows a fixed work order, and only counts as done when
+that **job** is accepted — not after a lucky chat.
 
-Cursor is the labor. Duaer is hire → assign → accept.
+Cursor is the labor. Duaer is hire → assign → accept.  
+**Not** a git merge lock. Controllability is job etiquette + optional strictness.
 
 ## Install (onboard the employee)
 
 ```bash
 npx duaer-spec init --here
-# or pin: npx github:fujiezee/duaer-spec@v0.2.0 duaer init --here
+# or pin: npx github:fujiezee/duaer-spec@v0.3.0 duaer init --here
 ```
 
 ```bash
-# Lite: method only (personal / small changes)
 npx duaer-spec init --here --method
-
-# Full ops on another integration branch
 npx duaer-spec init --here --ops --branch develop
 ```
 
-Verify: `npx duaer-spec check .`  
-Merge gate: `npx duaer-spec check . --gate`  
+```bash
+duaer policy .          # default: coach
+duaer job .             # active job handoff status
+duaer check .
+```
+
 Details: [`ADOPT.md`](ADOPT.md)
 
 ## How you run them
 
 | Step | Meaning | Command |
 |---|---|---|
-| **Hire** | Install SOP + gates into the repo | `duaer init` |
-| **Assign** | Write the Brief (what / why / acceptance) | `/duaer-specify` |
+| **Hire** | Install SOP into the project | `duaer init` |
+| **Assign** | Brief + set active job | `/duaer-specify` |
 | **Work** | Plan, break down, implement | `/duaer-plan` → `/duaer-tasks` → `/duaer-implement` |
-| **Accept** | Converge stamps `delivery.json`; gaps stay open | `/duaer-converge` |
-| **Gate** | Machine check before merge | `duaer check . --gate` |
+| **Accept** | Converge stamps `delivery.json` | `/duaer-converge` |
+| **Handoff** | See if this job may be reported done | `duaer job .` |
 
-Never skip **Assign** or **Accept**. Hotfix may shorten the middle; Spec,
-converge, and the gate stay.
+### Policy (job-level)
 
-### What the gate actually enforces
+Stored in `.duaer/delivery-policy.json`:
 
-`duaer check --gate` fails when any feature under `.duaer/specs/` has:
+| Mode | Behavior |
+|---|---|
+| `off` | Record only |
+| `coach` | **Default** — guide; do not claim "done" until accepted |
+| `strict` | Refuse to report done; `duaer check --strict` exits 1 on unfinished job |
 
-- missing `spec.md`
-- open `- [ ]` tasks in `tasks.md`
-- missing `delivery.json`, or `status` other than `accepted`
-
-Converge judgment is still agent-assisted. The gate makes **handoff state**
-checkable (and CI-friendly), not a substitute for tests.
+Scope is the **active job** (`.duaer/active-job.json`), not every historical feature.
+Git commit/merge is never blocked by default.
 
 ## Two layers
 
 | Layer | Role | Where |
 |---|---|---|
-| **Agent ops** | How the employee is allowed to operate | [`AGENTS.md`](AGENTS.md), [`docs/agent/`](docs/agent/) |
-| **Duaer method** | What to build (Spec → Plan → Tasks → Implement → Converge) | [`DUADER.md`](DUADER.md), [`.duaer/`](.duaer/), [`.cursor/skills/`](.cursor/skills/) |
+| **Agent ops** | How the employee may operate | [`AGENTS.md`](AGENTS.md), [`docs/agent/`](docs/agent/) |
+| **Duaer method** | What to build | [`DUADER.md`](DUADER.md), [`.duaer/`](.duaer/), skills |
 
-When they conflict, **agent ops win** — process beats improvisation.
+When they conflict, **agent ops win**.
 
 ## Default loop
 
 ```text
-constitution → specify → plan → tasks → implement → converge → check --gate
+constitution → specify → plan → tasks → implement → converge → duaer job
 ```
 
-Small change: `specify → plan → tasks → implement → converge`  
-Hotfix: `specify (hotfix) → tasks → implement → converge`
-
 Slash skills: `/duaer-specify`, `/duaer-plan`, `/duaer-tasks`, `/duaer-implement`,
 `/duaer-converge`, …
 
 ## Layout
 
 ```text
-bin/duaer.mjs             CLI (duaer init | check | version)
-package.json              npm package metadata
-AGENTS.md                 Agent-ops contract (how employees operate)
-DUADER.md                 Methodology conventions (how work is briefed)
-ADOPT.md                  Onboarding guide
-.duaer/                   Memory, templates, workflows, scripts
-.duaer/specs/<feature>/   Brief + tasks + delivery.json stamp
-.cursor/rules/            Agent-ops + Duaer rules
-.cursor/skills/           duaer-* skills
-docs/agent/               Workflow detail + checklists
-docs/maintaining.md       How maintainers evolve the method
-docs/npm-trusted-publishing.md  npm Trusted Publishing (OIDC) setup
-examples/                 Optional product overlays (not defaults)
+bin/duaer.mjs                  CLI (init | check | job | policy | version)
+.duaer/delivery-policy.json    off | coach | strict
+.duaer/active-job.json         current job pointer
+.duaer/specs/<feature>/        Brief + tasks + delivery.json
 ```
 
-## Defaults (this repo)
-
-- Integration branch: **`main`**
-- One request → one branch + one worktree → merge → delete worktree
-- Push only when explicitly requested
-
 ## Learn more
 
 Method: [`DUADER.md`](DUADER.md) · Agent ops: [`AGENTS.md`](AGENTS.md)

package/bin/duaer.mjs

@@ -3,7 +3,9 @@
  * duaer — CLI for the duaer-spec delivery OS (digital employees)
  *
  *   duaer init [dir] [--all|--method|--ops] [--force] [--branch <name>]
- *   duaer check [dir] [--workplace|--delivery|--gate]
+ *   duaer check [dir] [--workplace|--delivery|--job|--all-jobs|--strict]
+ *   duaer job [dir]
+ *   duaer policy [dir] [off|coach|strict]
  *   duaer version
  *   duaer help
  */
@@ -24,35 +26,48 @@ const __dirname = dirname(fileURLToPath(import.meta.url))
 const PKG_ROOT = resolve(__dirname, '..')
 const PKG = JSON.parse(readFileSync(join(PKG_ROOT, 'package.json'), 'utf8'))
 
+const POLICY_MODES = new Set(['off', 'coach', 'strict'])
+
 const USAGE = `duaer — Delivery OS for AI digital employees (duaer-spec ${PKG.version})
 
-Hire agents into a repo, assign Briefs (Specs), accept only when the gate passes.
+Job-level handoff (not a repo merge lock). Default policy: coach.
 
 Usage:
-  duaer init [dir] [options]     Hire / onboard into a project
-  duaer check [dir] [options]    Workplace + delivery status
-  duaer version                  Print version
-  duaer help                     Show this help
+  duaer init [dir] [options]              Hire / onboard into a project
+  duaer check [dir] [options]             Workplace + active-job handoff
+  duaer job [dir]                         Show the active job status
+  duaer policy [dir] [off|coach|strict]   Show or set handoff policy
+  duaer version                           Print version
+  duaer help                              Show this help
 
 Init options:
   --all          Full hire: agent ops + method (default)
-  --method       Lite: method only (.duaer, skills, DUADER.md, duaer-spec rule)
-  --ops          Ops only (AGENTS.md, docs/agent, ops rules)
+  --method       Lite: method only
+  --ops          Ops only
   --force        Overwrite existing managed files
   --branch <n>   Integration branch for baseline note (default: main)
   --here         Same as dir=.
 
 Check options:
   --workplace    Only verify install files
-  --delivery     Only report feature Brief / open tasks / delivery.json
-  --gate         Fail unless every feature is accepted (merge gate)
-  (default)      Workplace + delivery report; exit 1 on workplace miss
-                 or delivery blockers (missing Spec / open tasks / open stamp)
+  --delivery     Alias for active-job handoff report
+  --job          Active job only (default for delivery)
+  --all-jobs     Report every feature under .duaer/specs/
+  --strict       Exit 1 if active job is not accepted (optional)
+  --gate         Deprecated alias for --strict (job handoff, not CI)
+
+Policy modes (stored in .duaer/delivery-policy.json):
+  off     Record only; never fail handoff
+  coach   Default — guide / warn; do not claim "done" until accepted
+  strict  Agents must not report delivery complete until accepted;
+          duaer check exits 1 on unfinished active job
 
 Examples:
   npx duaer-spec init --here
+  duaer job .
+  duaer policy . coach
   duaer check .
-  duaer check . --gate
+  duaer check . --strict
 `
 
 function parseArgs(argv) {
@@ -65,7 +80,10 @@ function parseArgs(argv) {
     branch: 'main',
     workplace: false,
     delivery: false,
-    gate: false,
+    job: false,
+    allJobs: false,
+    strict: false,
+    policyMode: null,
   }
   const rest = args.slice(1)
   for (let i = 0; i < rest.length; i++) {
@@ -77,12 +95,18 @@ function parseArgs(argv) {
     else if (a === '--here') out.dir = '.'
     else if (a === '--workplace') out.workplace = true
     else if (a === '--delivery') out.delivery = true
-    else if (a === '--gate') out.gate = true
+    else if (a === '--job') out.job = true
+    else if (a === '--all-jobs') out.allJobs = true
+    else if (a === '--strict' || a === '--gate') out.strict = true
     else if (a === '--branch') {
       out.branch = rest[++i]
       if (!out.branch) throw new Error('--branch requires a value')
+    } else if (POLICY_MODES.has(a) && out.cmd === 'policy') {
+      out.policyMode = a
     } else if (a.startsWith('-')) {
       throw new Error(`Unknown flag: ${a}`)
+    } else if (out.cmd === 'policy' && POLICY_MODES.has(a)) {
+      out.policyMode = a
     } else {
       out.dir = a
     }
@@ -124,10 +148,62 @@ function writeIfNeeded(path, content, { force }) {
   console.log(`wrote ${path}`)
 }
 
+function readJson(path, fallback = null) {
+  if (!existsSync(path)) return fallback
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'))
+  } catch {
+    return fallback
+  }
+}
+
+function defaultPolicy() {
+  return {
+    schemaVersion: 1,
+    mode: 'coach',
+    scope: 'active',
+    notes:
+      'Job-level handoff. off=record only; coach=guide (default); strict=do not claim done until accepted. Not a git merge lock.',
+  }
+}
+
+function policyPath(target) {
+  return join(target, '.duaer', 'delivery-policy.json')
+}
+
+function activeJobPath(target) {
+  return join(target, '.duaer', 'active-job.json')
+}
+
+function loadPolicy(target) {
+  const p = readJson(policyPath(target), null)
+  if (!p) return defaultPolicy()
+  const mode = POLICY_MODES.has(p.mode) ? p.mode : 'coach'
+  return { ...defaultPolicy(), ...p, mode }
+}
+
+function writePolicy(target, mode) {
+  const next = { ...defaultPolicy(), mode, updatedAt: new Date().toISOString() }
+  ensureDir(join(target, '.duaer'))
+  writeFileSync(policyPath(target), JSON.stringify(next, null, 2) + '\n')
+  return next
+}
+
+function writeDefaultPolicy(target, { force }) {
+  const path = policyPath(target)
+  if (existsSync(path) && !force) {
+    console.log(`skip (exists): ${path}`)
+    return
+  }
+  writeFileSync(path, JSON.stringify(defaultPolicy(), null, 2) + '\n')
+  console.log('  .duaer/delivery-policy.json (mode=coach)')
+}
+
 function installMethod(target, opts) {
   console.log('Installing Duaer method…')
   copyPath(join(PKG_ROOT, '.duaer'), join(target, '.duaer'), opts)
   console.log('  .duaer/')
+  writeDefaultPolicy(target, opts)
 
   ensureDir(join(target, '.cursor', 'skills'))
   const skillsRoot = join(PKG_ROOT, '.cursor', 'skills')
@@ -234,17 +310,17 @@ function cmdInit(opts) {
   console.log(`
 Hired.
 
-Next (digital employee loop):
+Next (digital employee loop — job handoff, not a repo lock):
   1. Orient  — edit .duaer/memory/constitution.md and project-context.md
-  2. Workplace — confirm docs/baseline.md (integration branch: ${opts.branch})
-  3. Assign  — /duaer-specify  (Brief: what / why / acceptance)
+  2. Policy  — duaer policy .   (default coach; optional: off | strict)
+  3. Assign  — /duaer-specify   (sets active job + Brief)
   4. Work    — /duaer-plan → /duaer-tasks → /duaer-implement
-  5. Accept  — /duaer-converge  (writes delivery.json; gaps stay open)
-  6. Gate    — duaer check . --gate  before merge
-  7. Policy  — AGENTS.md wins over DUADER.md when they conflict
+  5. Accept  — /duaer-converge  (stamps delivery.json)
+  6. Job     — duaer job .      (see if this job can be reported done)
+  7. Ops     — AGENTS.md wins over DUADER.md when they conflict
 
-No Spec = not assigned. Open tasks or open delivery.json = not accepted.
-See DUADER.md and AGENTS.md in the target project.
+No Spec = not assigned. Unaccepted active job = do not claim "done".
+Git merge is not blocked by default.
 `)
 }
 
@@ -265,6 +341,55 @@ function readDelivery(path) {
   }
 }
 
+function featureVerdict(name, dir) {
+  const specPath = join(dir, 'spec.md')
+  const tasksPath = join(dir, 'tasks.md')
+  const deliveryPath = join(dir, 'delivery.json')
+  const tasks = countOpenTasks(tasksPath)
+  const delivery = readDelivery(deliveryPath)
+  const hasSpec = existsSync(specPath)
+  const stamp = delivery?.status || 'none'
+  let verdict = 'accepted'
+  const blockers = []
+
+  if (!hasSpec) {
+    verdict = 'blocked'
+    blockers.push('missing spec.md')
+  }
+  if (tasks && tasks.open > 0) {
+    verdict = 'blocked'
+    blockers.push(`${tasks.open} open task(s)`)
+  }
+  if (stamp === 'open' || stamp === 'invalid') {
+    verdict = 'blocked'
+    blockers.push(`delivery.json status=${stamp}`)
+  }
+  if (hasSpec && tasks && tasks.open === 0 && (stamp === 'none' || !delivery)) {
+    verdict = 'unaccepted'
+    blockers.push('no delivery.json (run /duaer-converge)')
+  }
+  if (hasSpec && !tasks && (stamp === 'none' || !delivery)) {
+    verdict = 'unaccepted'
+    blockers.push('no tasks.md / no delivery.json')
+  }
+  if (stamp === 'accepted' && tasks && tasks.open === 0 && hasSpec) {
+    verdict = 'accepted'
+    blockers.length = 0
+  } else if (stamp === 'accepted' && (!tasks || tasks.open === 0) && hasSpec && !tasks) {
+    // accepted stamp with no tasks file — treat as accepted only if stamp says so
+    // keep unaccepted path above for !tasks && no stamp
+  }
+
+  // Stamp accepted but open tasks remain → blocked (fake stamp)
+  if (stamp === 'accepted' && tasks && tasks.open > 0) {
+    verdict = 'blocked'
+    blockers.length = 0
+    blockers.push('delivery.json accepted but open tasks remain')
+  }
+
+  return { name, hasSpec, tasks, stamp, verdict, blockers }
+}
+
 function listFeatures(target) {
   const root = join(target, '.duaer', 'specs')
   if (!existsSync(root)) return []
@@ -277,53 +402,28 @@ function listFeatures(target) {
       }
     })
     .sort()
-    .map((name) => {
-      const dir = join(root, name)
-      const specPath = join(dir, 'spec.md')
-      const tasksPath = join(dir, 'tasks.md')
-      const deliveryPath = join(dir, 'delivery.json')
-      const tasks = countOpenTasks(tasksPath)
-      const delivery = readDelivery(deliveryPath)
-      const hasSpec = existsSync(specPath)
-      const stamp = delivery?.status || 'none'
-      let verdict = 'accepted'
-      const blockers = []
-
-      if (!hasSpec) {
-        verdict = 'blocked'
-        blockers.push('missing spec.md')
-      }
-      if (tasks && tasks.open > 0) {
-        verdict = 'blocked'
-        blockers.push(`${tasks.open} open task(s)`)
-      }
-      if (stamp === 'open' || stamp === 'invalid') {
-        verdict = 'blocked'
-        blockers.push(`delivery.json status=${stamp}`)
-      }
-      if (hasSpec && tasks && tasks.open === 0 && (stamp === 'none' || !delivery)) {
-        // Brief exists and tasks clear, but never stamped by converge
-        verdict = 'unaccepted'
-        blockers.push('no delivery.json (run /duaer-converge)')
-      }
-      if (hasSpec && !tasks && (stamp === 'none' || !delivery)) {
-        verdict = 'unaccepted'
-        blockers.push('no tasks.md / no delivery.json')
-      }
-      if (stamp === 'accepted' && tasks && tasks.open === 0 && hasSpec) {
-        verdict = 'accepted'
-        blockers.length = 0
-      }
+    .map((name) => featureVerdict(name, join(root, name)))
+}
 
-      return {
-        name,
-        hasSpec,
-        tasks,
-        stamp,
-        verdict,
-        blockers,
-      }
-    })
+function resolveActiveJobName(target, features) {
+  const marker = readJson(activeJobPath(target), null)
+  if (marker?.feature && features.some((f) => f.name === marker.feature)) {
+    return marker.feature
+  }
+  if (features.length === 0) return null
+  // Prefer newest directory name (lexicographic works for NNN-slug)
+  return features[features.length - 1].name
+}
+
+function printFeature(f, { label } = {}) {
+  const taskInfo = f.tasks
+    ? `tasks open=${f.tasks.open} done=${f.tasks.done}`
+    : 'no tasks.md'
+  const prefix = label ? `${label} ` : ''
+  console.log(
+    `${prefix}${f.verdict.padEnd(10)} ${f.name}  spec=${f.hasSpec ? 'yes' : 'NO'}  stamp=${f.stamp}  ${taskInfo}`,
+  )
+  for (const b of f.blockers) console.log(`           · ${b}`)
 }
 
 function checkWorkplace(target) {
@@ -346,51 +446,91 @@ function checkWorkplace(target) {
   return missing
 }
 
-function checkDelivery(target, { gate }) {
+function checkDelivery(target, { allJobs, policy }) {
   const features = listFeatures(target)
-  console.log('\n## Delivery\n')
+  const activeName = resolveActiveJobName(target, features)
+  const active = features.find((f) => f.name === activeName) || null
+
+  console.log('\n## Handoff (jobs)\n')
+  console.log(`policy: ${policy.mode}  scope: ${allJobs ? 'all' : 'active'}`)
+
   if (features.length === 0) {
-    console.log('ok   no features under .duaer/specs/ (nothing to accept)')
-    return { blocked: 0, unaccepted: 0, features: 0 }
+    console.log('ok   no features under .duaer/specs/ (nothing to hand off)')
+    return { blocked: 0, unaccepted: 0, features: 0, active: null, unfinished: false }
   }
 
+  if (allJobs) {
+    for (const f of features) {
+      printFeature(f, { label: f.name === activeName ? '★' : ' ' })
+    }
+  } else if (active) {
+    printFeature(active, { label: '★' })
+    console.log(`\nactive job: ${active.name}  (from .duaer/active-job.json or latest spec)`)
+  } else {
+    console.log('ok   no resolvable active job')
+  }
+
+  const focus = allJobs ? features : active ? [active] : []
   let blocked = 0
   let unaccepted = 0
-  for (const f of features) {
-    const taskInfo = f.tasks
-      ? `tasks open=${f.tasks.open} done=${f.tasks.done}`
-      : 'no tasks.md'
-    const line = `${f.verdict.padEnd(10)} ${f.name}  spec=${f.hasSpec ? 'yes' : 'NO'}  stamp=${f.stamp}  ${taskInfo}`
-    console.log(line)
-    if (f.blockers.length) {
-      for (const b of f.blockers) console.log(`           · ${b}`)
-    }
+  for (const f of focus) {
     if (f.verdict === 'blocked') blocked++
     if (f.verdict === 'unaccepted') unaccepted++
   }
+  const unfinished = blocked + unaccepted > 0
+  return { blocked, unaccepted, features: focus.length, active, unfinished }
+}
 
-  if (gate) {
-    console.log('\nGate mode: every feature must be accepted.')
+function handoffAdvice(policy, unfinished, strictFlag) {
+  if (!unfinished) {
+    console.log('\nActive job accepted — employee may report delivery complete.')
+    return
+  }
+  if (policy.mode === 'off' && !strictFlag) {
+    console.log('\nHandoff incomplete (policy=off) — recorded only.')
+    return
+  }
+  if (policy.mode === 'coach' && !strictFlag) {
+    console.log(`
+Coach: this job is not accepted yet.
+  → close open tasks, run /duaer-converge, then duaer job .
+  → do not tell the user the work is "done" until status=accepted
+  → git is not blocked; this is job etiquette, not a merge lock
+`)
+    return
   }
-  return { blocked, unaccepted, features: features.length }
+  console.log(`
+Strict: active job not accepted — exit 1.
+  → /duaer-converge until delivery.json status=accepted and tasks clear
+`)
 }
 
 function cmdCheck(opts) {
   const target = resolve(opts.dir)
-  // Default: workplace + delivery. --gate alone is delivery-only (merge gate).
-  const runWorkplace = opts.workplace || (!opts.delivery && !opts.gate)
-  const runDelivery = opts.delivery || opts.gate || !opts.workplace
+  const policy = loadPolicy(target)
+  const strictFlag = opts.strict || policy.mode === 'strict'
+
+  // default: workplace + delivery; --workplace alone; job/delivery/strict/all-jobs → delivery
+  let wp = false
+  let del = false
+  if (opts.workplace && !opts.delivery && !opts.job && !opts.allJobs && !opts.strict) {
+    wp = true
+  } else if (opts.delivery || opts.job || opts.allJobs || opts.strict) {
+    del = true
+    if (opts.workplace) wp = true
+  } else {
+    wp = true
+    del = true
+  }
 
-  console.log(`Checking ${target}${opts.gate ? ' (gate)' : ''}\n`)
+  console.log(`Checking ${target}${strictFlag ? ' (strict handoff)' : ''}\n`)
 
   let workplaceMissing = 0
-  if (runWorkplace) {
-    workplaceMissing = checkWorkplace(target)
-  }
+  if (wp) workplaceMissing = checkWorkplace(target)
 
-  let delivery = { blocked: 0, unaccepted: 0, features: 0 }
-  if (runDelivery) {
-    delivery = checkDelivery(target, { gate: opts.gate })
+  let delivery = { unfinished: false }
+  if (del) {
+    delivery = checkDelivery(target, { allJobs: opts.allJobs, policy })
   }
 
   let fail = false
@@ -399,36 +539,76 @@ function cmdCheck(opts) {
     fail = true
   }
 
-  if (runDelivery) {
-    if (delivery.blocked) {
-      console.log(`\n${delivery.blocked} feature(s) blocked — close open tasks / fix Spec / re-run converge`)
+  if (del) {
+    handoffAdvice(policy, delivery.unfinished, opts.strict)
+    if (delivery.unfinished && strictFlag) {
       fail = true
     }
-    if (opts.gate && delivery.unaccepted) {
-      console.log(
-        `\n${delivery.unaccepted} feature(s) not accepted — run /duaer-converge until delivery.json status=accepted`,
-      )
-      fail = true
-    } else if (!opts.gate && delivery.unaccepted) {
-      console.log(
-        `\n${delivery.unaccepted} feature(s) not yet accepted (warning). Use --gate to fail the merge check.`,
-      )
-    }
   }
 
   if (!fail) {
-    if (opts.gate) {
-      console.log('\nGate passed — deliverable.')
-    } else if (runWorkplace && !workplaceMissing) {
-      console.log('\nWorkplace ready. Use --gate before merge when features exist.')
+    if (wp && !workplaceMissing && !del) {
+      console.log('\nWorkplace ready.')
+    } else if (!delivery.unfinished) {
+      console.log('\nCheck ok.')
     } else {
-      console.log('\nDelivery report done.')
+      console.log('\nCheck ok (handoff still open under coach/off — see above).')
     }
   } else {
     process.exitCode = 1
   }
 }
 
+function cmdJob(opts) {
+  const target = resolve(opts.dir)
+  const policy = loadPolicy(target)
+  const features = listFeatures(target)
+  const activeName = resolveActiveJobName(target, features)
+  const active = features.find((f) => f.name === activeName) || null
+
+  console.log(`Active job @ ${target}`)
+  console.log(`policy: ${policy.mode}\n`)
+  if (!active) {
+    console.log('No active job. Assign with /duaer-specify (writes .duaer/active-job.json).')
+    return
+  }
+  printFeature(active)
+  if (active.verdict === 'accepted') {
+    console.log('\nHandoff script: "✅ Job accepted — Brief satisfied per converge; ready for your review."')
+  } else {
+    console.log('\nHandoff script: "This job is not accepted yet — Spec/tasks/converge still open."')
+    if (policy.mode !== 'off') {
+      console.log('Do not claim delivery complete until duaer job shows accepted.')
+    }
+  }
+}
+
+function cmdPolicy(opts) {
+  const target = resolve(opts.dir)
+  if (opts.policyMode) {
+    if (!POLICY_MODES.has(opts.policyMode)) {
+      throw new Error(`Unknown policy mode: ${opts.policyMode}`)
+    }
+    const next = writePolicy(target, opts.policyMode)
+    console.log(`Wrote ${policyPath(target)}`)
+    console.log(`mode: ${next.mode}`)
+    return
+  }
+  const policy = loadPolicy(target)
+  const exists = existsSync(policyPath(target))
+  console.log(`Policy @ ${target}`)
+  console.log(`file:  ${exists ? policyPath(target) : '(defaults; run init or: duaer policy . coach)'}`)
+  console.log(`mode:  ${policy.mode}`)
+  console.log(`scope: ${policy.scope || 'active'}`)
+  console.log(`
+Modes:
+  off     record only
+  coach   guide; do not claim done until accepted (default)
+  strict  check fails + agents must not report done until accepted
+Not a git merge lock.
+`)
+}
+
 function main() {
   let opts
   try {
@@ -447,6 +627,12 @@ function main() {
       case 'check':
         cmdCheck(opts)
         break
+      case 'job':
+        cmdJob(opts)
+        break
+      case 'policy':
+        cmdPolicy(opts)
+        break
       case 'version':
       case '--version':
       case '-v':

package/docs/agent/change-checklist.md

@@ -94,7 +94,7 @@ See [spec update guidance](workflow.md#3-spec-update-guidance).
 
 ## 6. Merge / PR
 
-- [ ] `duaer check . --gate` passed (or no `.duaer/specs/` features yet).
+- [ ] Active job handoff considered: `duaer job .` (coach/strict: do not claim done if unfinished).
 - [ ] Branch refreshed against latest `main`.
 - [ ] Merged into local `main` (and/or remote PR/MR when required).
 - [ ] Only this request's logical changes included.
@@ -122,7 +122,7 @@ See [spec update guidance](workflow.md#3-spec-update-guidance).
 | 3 | Impacted specs updated | [R1](workflow.md#r1--spec-first--spec-sync) |
 | 4 | E2E docs updated or confirmed unnecessary | [R3](workflow.md#r3--e2e-coverage-doc) |
 | 5 | Targeted validation done or waived with reason | Development loop |
-| 5a | `duaer check . --gate` when features exist | Delivery OS gate |
+| 5a | Active job handoff via `duaer job` (coach/strict) | Delivery OS — not a git lock |
 | 6 | Conventional commits | [R2](workflow.md#r2--commit-per-change) |
 | 7 | No secrets or local data | [§4](workflow.md#4-what-never-to-commit) |
 | 8 | Merged into `main`; worktree and branch removed | [R4](workflow.md#r4--request-branch--worktree--merge-gate) · [§6.1](#61-merge-cleanup) |

package/docs/agent/e2e-test-plan.md

@@ -27,9 +27,11 @@ the table for their app.
 |---|---|---|
 | E2E-001 | After `duaer init`, CLI prints hire → assign → accept next steps | manual |
 | E2E-002 | README positions Duaer as delivery OS for digital employees | manual |
-| E2E-003 | `duaer check --delivery` reports open tasks as blocked | manual |
-| E2E-004 | `duaer check --gate` fails without `delivery.json` accepted | manual |
-| E2E-005 | After converge stamps `accepted`, `--gate` passes | manual |
+| E2E-003 | `duaer check --job` reports open tasks on active job | manual |
+| E2E-004 | Default `coach` policy: unfinished job warns but check exits 0 | manual |
+| E2E-005 | After converge stamps `accepted`, `duaer job` shows accepted | manual |
+| E2E-006 | `duaer policy . strict` then unfinished job makes check exit 1 | manual |
+| E2E-007 | `--all-jobs` is optional; default scope is active job only | manual |
 
 ## Traceability
 
@@ -37,8 +39,10 @@ Keep this matrix current when scenarios or specs change.
 
 | Scenario | Spec / feature | Notes |
 |---|---|---|
-| E2E-001 | `bin/duaer.mjs` init banner | Controllable-delivery onboarding |
+| E2E-001 | `bin/duaer.mjs` init banner | Onboarding |
 | E2E-002 | `README.md` / `ADOPT.md` | Product identity |
-| E2E-003 | `bin/duaer.mjs` delivery check | Open `- [ ]` tasks |
-| E2E-004 | `bin/duaer.mjs` `--gate` | Merge gate |
+| E2E-003 | active job delivery check | Open `- [ ]` |
+| E2E-004 | `delivery-policy.json` coach | Not a repo lock |
 | E2E-005 | `/duaer-converge` → `delivery.json` | Accept stamp |
+| E2E-006 | policy strict | Optional hardness |
+| E2E-007 | `--all-jobs` vs active | Scope |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duaer-spec",
-  "version": "0.2.0",
-  "description": "Delivery OS for AI digital employees: Spec briefs, agent ops, check --gate handoffs",
+  "version": "0.3.0",
+  "description": "Delivery OS for AI digital employees: job handoff (coach/strict), Spec briefs, agent ops",
   "type": "module",
   "bin": {
     "duaer": "bin/duaer.mjs",