duaer-spec 0.1.1 → 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,4 +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
+- Run the verification named in the feature docs
+- Before claiming done: `duaer job .` shows accepted (coach/strict)

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

@@ -71,10 +71,17 @@ of remaining work as a new, traceable task** at the bottom of `tasks.md` so that
 This is **not** a diff tool and does **not** track changes. It assesses the present state
 of the code relative to the feature's artifacts — no git, no branch comparison, no history.
 
+**Delivery stamp:** Always update `FEATURE_DIR/delivery.json` after assessment (see Step 7).
+That file is what `duaer check --gate` reads for machine-checkable acceptance.
+
 ## Operating Constraints
 
-**APPEND-ONLY, NEVER REWRITE**: The command's **only** write is appending a new
-`## Phase N: Convergence` section to `tasks.md`. It MUST NOT:
+**APPEND-ONLY FOR TASKS, STAMP FOR DELIVERY**: The command's writes are limited to:
+
+1. appending a new `## Phase N: Convergence` section to `tasks.md` when findings exist;
+2. writing / overwriting `FEATURE_DIR/delivery.json` (the machine-readable accept stamp).
+
+It MUST NOT:
 
 - modify `spec.md` or `plan.md` in any way;
 - rewrite, renumber, reorder, or delete any existing task (including tasks from a prior
@@ -83,7 +90,8 @@ of the code relative to the feature's artifacts — no git, no branch comparison
   job of `/duaer-implement`.
 
 When the codebase already satisfies everything, the command MUST leave `tasks.md`
-**byte-for-byte unchanged** (no empty Convergence header) and report a clean result.
+**byte-for-byte unchanged** (no empty Convergence header) and still write
+`delivery.json` with `status: "accepted"`.
 
 **Constitution Authority**: The project constitution (`.duaer/memory/constitution.md`) is
 **non-negotiable**. Code that violates a MUST principle is the highest-severity finding and
@@ -221,20 +229,54 @@ Append to the **end** of `tasks.md`, per the append contract:
    `CRITICAL`.
 4. Never reuse or renumber existing IDs. If a prior Convergence phase exists, add a new,
    separately-numbered one below it — do not touch the old one.
+5. **Write / overwrite** `FEATURE_DIR/delivery.json`:
+
+   ```json
+   {
+     "schemaVersion": 1,
+     "status": "open",
+     "outcome": "tasks_appended",
+     "checkedAt": "<ISO-8601 UTC>",
+     "openTasks": <count of - [ ] in tasks.md after append>,
+     "findings": <number of findings appended>,
+     "source": "duaer-converge"
+   }
+   ```
 
 **If there are no actionable findings** (`converged` outcome):
 
 - Do **not** modify `tasks.md` at all — no empty phase header.
+- **Write / overwrite** `FEATURE_DIR/delivery.json` with:
+
+  ```json
+  {
+    "schemaVersion": 1,
+    "status": "accepted",
+    "outcome": "converged",
+    "checkedAt": "<ISO-8601 UTC>",
+    "openTasks": 0,
+    "findings": 0,
+    "source": "duaer-converge"
+  }
+  ```
+
+  Set `openTasks` to the count of unchecked `- [ ]` lines currently in `tasks.md`
+  (must be `0` for `status: "accepted"`; if any remain, treat as `tasks_appended`
+  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 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.
-- On `converged`: recommend proceeding to review / opening a PR. No further implement pass
-  is needed for this feature's specified scope.
+  run will find fewer or no remaining items. Remind: `delivery.json` is `open` —
+  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

@@ -35,3 +35,14 @@ 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.
+
+**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.1.1 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,10 +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** — `/duaer-specify` → `/duaer-plan` → `/duaer-tasks` → `/duaer-implement` → `/duaer-converge`
+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. A change that fails converge is not accepted.
+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,39 @@
 # 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)
+
+- `/duaer-converge` writes `.duaer/specs/<feature>/delivery.json`
+  (`accepted` | `open`)
+- `duaer check` reports workplace **and** delivery status
+- `duaer check --gate` fails on missing Spec, open tasks, or non-accepted stamp
+- Constitution, DUADER, README, ADOPT, and merge checklist require the gate
+- Honest scope: gate checks **handoff state**; Spec↔code judgment remains
+  agent-assisted
+
+### E2E
+
+- E2E-003 / E2E-004 / E2E-005 for delivery report and gate
+
 ## 0.1.1 — 2026-09-15
 
 ### Docs / product identity
@@ -30,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,57 +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; append remaining tasks if gaps
+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  
+**Small feature:** specify → plan → tasks → implement → converge → `duaer job`  
 
-**Hotfix:** specify (mark hotfix) → tasks → implement → converge  
-Never skip specify (assign) or converge (accept).
+**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
-  …            # research / contracts as needed
+  spec.md         # Brief
+  plan.md
+  tasks.md
+  delivery.json   # accepted | open
 ```
 
 ## Related

package/README.md

@@ -3,86 +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 after
-acceptance — 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.1.1 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 .`  
+```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** | Compare result to Spec; gaps become more work | `/duaer-converge` + `duaer check` |
+| **Accept** | Converge stamps `delivery.json` | `/duaer-converge` |
+| **Handoff** | See if this job may be reported done | `duaer job .` |
+
+### Policy (job-level)
 
-Never skip **Assign** or **Accept**. Hotfix may shorten the middle; Spec and
-converge stay.
+Stored in `.duaer/delivery-policy.json`:
+
+| 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 |
+
+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
+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
-.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]
+ *   duaer check [dir] [--workplace|--delivery|--job|--all-jobs|--strict]
+ *   duaer job [dir]
+ *   duaer policy [dir] [off|coach|strict]
  *   duaer version
  *   duaer help
  */
@@ -24,29 +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 converge 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]            Verify install (workplace ready)
-  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     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
-  npx github:fujiezee/duaer-spec duaer init --here
-  node bin/duaer.mjs init ../my-app --all
+  duaer job .
+  duaer policy . coach
   duaer check .
+  duaer check . --strict
 `
 
 function parseArgs(argv) {
@@ -57,6 +78,12 @@ function parseArgs(argv) {
     mode: 'all',
     force: false,
     branch: 'main',
+    workplace: false,
+    delivery: false,
+    job: false,
+    allJobs: false,
+    strict: false,
+    policyMode: null,
   }
   const rest = args.slice(1)
   for (let i = 0; i < rest.length; i++) {
@@ -66,11 +93,20 @@ function parseArgs(argv) {
     else if (a === '--ops') out.mode = 'ops'
     else if (a === '--force') out.force = true
     else if (a === '--here') out.dir = '.'
+    else if (a === '--workplace') out.workplace = true
+    else if (a === '--delivery') out.delivery = 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
     }
@@ -89,7 +125,6 @@ function copyPath(from, to, { force }) {
   if (existsSync(to) && !force) {
     const st = statSync(to)
     if (st.isDirectory()) {
-      // merge: copy children carefully
       for (const name of readdirSync(from)) {
         copyPath(join(from, name), join(to, name), { force })
       }
@@ -113,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')
@@ -223,21 +310,123 @@ 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  (gaps are not done; append tasks)
-  6. Gates   — 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. Failed converge = 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.
 `)
 }
 
-function cmdCheck(dir) {
-  const target = resolve(dir)
+function countOpenTasks(tasksPath) {
+  if (!existsSync(tasksPath)) return null
+  const text = readFileSync(tasksPath, 'utf8')
+  const open = (text.match(/^\s*-\s*\[\s\]/gm) || []).length
+  const done = (text.match(/^\s*-\s*\[x\]/gim) || []).length
+  return { open, done }
+}
+
+function readDelivery(path) {
+  if (!existsSync(path)) return null
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'))
+  } catch {
+    return { status: 'invalid', error: 'unreadable delivery.json' }
+  }
+}
+
+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 []
+  return readdirSync(root)
+    .filter((name) => {
+      try {
+        return statSync(join(root, name)).isDirectory()
+      } catch {
+        return false
+      }
+    })
+    .sort()
+    .map((name) => featureVerdict(name, join(root, name)))
+}
+
+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) {
   const checks = [
     ['.duaer/memory/constitution.md', 'method'],
     ['DUADER.md', 'method'],
@@ -248,20 +437,178 @@ function cmdCheck(dir) {
     ['docs/agent/workflow.md', 'ops'],
   ]
   let missing = 0
-  console.log(`Checking ${target}\n`)
+  console.log('## Workplace\n')
   for (const [rel, kind] of checks) {
     const ok = existsSync(join(target, rel))
     console.log(`${ok ? 'ok ' : 'MISS'}  [${kind}] ${rel}`)
     if (!ok) missing++
   }
-  if (missing) {
-    console.log(`\n${missing} missing — run: duaer init ${dir} --all`)
+  return missing
+}
+
+function checkDelivery(target, { allJobs, policy }) {
+  const features = listFeatures(target)
+  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 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 focus) {
+    if (f.verdict === 'blocked') blocked++
+    if (f.verdict === 'unaccepted') unaccepted++
+  }
+  const unfinished = blocked + unaccepted > 0
+  return { blocked, unaccepted, features: focus.length, active, unfinished }
+}
+
+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
+  }
+  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)
+  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}${strictFlag ? ' (strict handoff)' : ''}\n`)
+
+  let workplaceMissing = 0
+  if (wp) workplaceMissing = checkWorkplace(target)
+
+  let delivery = { unfinished: false }
+  if (del) {
+    delivery = checkDelivery(target, { allJobs: opts.allJobs, policy })
+  }
+
+  let fail = false
+  if (workplaceMissing) {
+    console.log(`\n${workplaceMissing} workplace file(s) missing — run: duaer init ${opts.dir} --all`)
+    fail = true
+  }
+
+  if (del) {
+    handoffAdvice(policy, delivery.unfinished, opts.strict)
+    if (delivery.unfinished && strictFlag) {
+      fail = true
+    }
+  }
+
+  if (!fail) {
+    if (wp && !workplaceMissing && !del) {
+      console.log('\nWorkplace ready.')
+    } else if (!delivery.unfinished) {
+      console.log('\nCheck ok.')
+    } else {
+      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('\nWorkplace ready — assign with /duaer-specify, accept with /duaer-converge.')
+    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 {
@@ -278,7 +625,13 @@ function main() {
         cmdInit(opts)
         break
       case 'check':
-        cmdCheck(opts.dir)
+        cmdCheck(opts)
+        break
+      case 'job':
+        cmdJob(opts)
+        break
+      case 'policy':
+        cmdPolicy(opts)
         break
       case 'version':
       case '--version':

package/docs/agent/change-checklist.md

@@ -94,6 +94,7 @@ See [spec update guidance](workflow.md#3-spec-update-guidance).
 
 ## 6. Merge / PR
 
+- [ ] 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.
@@ -121,6 +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 | 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,6 +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 --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
 
@@ -34,5 +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 | 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.1.1",
-  "description": "Delivery OS for AI digital employees: Spec briefs, agent ops, controllable 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",