work

# /work - Lifecycle Router `lev` is the public semantic router; `/work` is its compatibility lifecycle entry point. Both use the procedure below and the same workstream state, not two routers calling each other. When route-changing uncertainty remains after lookup, ask one to three focused questions and show viable owners/results as a numbered 1–n menu with one recommendation and free-text correction. A clear authorized request proceeds directly. "Take over" is metaphorical, not a command or a permission change. `/work` is the thin lifecycle spine. It does not re-implement capture, plan compilation, proposal, execution, close, or handoff protocols. It resolves workstream context, identifies the entity movement, and routes to the owning skill. For any non-trivial direct or routed invocation, load [Project Context](../lev/references/project-context.md) before project-specific lookup. It resolves the active project and its declared breadcrumbs. ## Entity Reconciliation After authorized material progress, reconcile touched and causally affected artifacts before routing, handoff, or final response. Track entity ref, island/provider locator (a path for file storage), basis/evidence, and the reason/action due. Update through the verified owning CLI/adapter; use a write-authorized skill fallback only when that operation is unavailable. Record updated, no_change(reason), or blocked(reason), preserving unresolved refs. Reading or mentioning a path alone creates no update obligation. Read-only work reports pending changes only. Reminders grant no write authority; task status stays with the bound tracker. Update only artifacts whose content or evidence changed; do not rewrite every referenced document. ## Work Link Lifecycle lane: Router Entity movement: `unknown -> routed` Workstream: resolve active workstream before writes or dispatch Upstream: any lifecycle skill or user request Downstream: `/ws`, `/capture`, `/prior-art`, `/interview`, `/lev-plan`, `/exec`, `/close`, `/handoff` Router: `/work` HUD: end with `🧬 {ws} ⚡{exec_count} 📥{capture_count} ⏸️{paused_count} ✅{done_count} | 🚦{gate}={score} | ⏭️ {next} | 🔁{loop_state}` ## Inline HUD Contract End lifecycle-skill responses with this inline HUD line: `🧬 {ws} ⚡{exec_count} 📥{capture_count} ⏸️{paused_count} ✅{done_count} | 🚦{gate}={score} | ⏭️ {next} | 🔁{loop_state}` The shared graph-footer partial is an authoring reference only until the Lev skill-builder pipeline can project FlowMind fragments into skill bodies. Do not make skills load or include that file at runtime. ## Human Response Contract Keep full ledgers, scores, traces, and gate state in durable artifacts. Default interactive output is a compact content-first projection; render the full table only for `--full`, explicit audit/debug requests, or when one row cannot be understood without it. Score the default response on these ten checks. A check may be `not_applicable` only with a concrete reason; every applicable check must pass. | # | Check | |---:|---| | 1 | Lead with the outcome or current state. | | 2 | Name the operator-visible result. | | 3 | Name the exact asset, code area, task, or durable entity affected. | | 4 | Name relevant code owners and rules/index refs when implementation is discussed. | | 5 | Show the real-world critical path when behavior crosses boundaries. | | 6 | Name the first executable or testable next slice. | | 7 | State what done means as an observable effect. | | 8 | State the smallest local, integration, or field proof that matters. | | 9 | Separate deterministic code, declarative policy, LLM work, and human decisions when relevant. | | 10 | End with one primary next action and any real blocker. | Default target: at most 12 non-blank lines before the optional HUD. Do not print an empty section or unrelated readiness matrix. `/capture` is the explicit exception: its source-fidelity table is always operator-visible because it proves that conversation intent reached disk. Render the Markdown inside live XML templates; never print the XML wrapper tags. <lifecycle-response> ## {outcome_or_state} Changed or saved: {durable_delta_or_none} Proof or state: {load_bearing_evidence_or_gap} Decision needed: {none_or_one_decision} Next: {one_primary_action} </lifecycle-response> ## Lifecycle Lanes The software lanes and task packet rules below simulate the `plugins/sdlc` overlay. For non-coding work, retain workstream identity and acceptance but use the selected domain's artifacts; a sufficient plan can route directly to its domain skill or `skill://exec` without an SDLC packet. ## Next-Step Mini-Router Project only eligible next transitions as a table with `#`, `Route`, and `Expected result`, using `skill://<name>` destinations and contiguous numbering. Choose from current state, active domain, missing decision and authorization; do not invent options to fill a menu or make all skills call each other. Proceed directly for a clear authorized route. Suggestions do not grant new authority. Unknown destinations return to `skill://lev`; paused work routes to `skill://handoff`. These inline runbooks are dogfood, not runtime enforcement. ## SDLC Lane Map | Lane | Entity movement | Owns | |---|---|---| | Shape | `memory -> captured | blocked` | `/capture`, `/prior-art`, `/interview` | | Plan | `captured | designed -> planned | proposed | execution_ready` | `/lev-plan` (`/propose` is its compatibility alias), `/capture` | | Exec | `execution_ready -> executing -> verified | blocked | needs_propose` | `/exec` | | Close | `verified -> closed | monitoring | follow_up` | `/close`, `/handoff` | | Router | `unknown -> routed` | `/work`, `/ws` | ## Entity Rules - Resolve the active workstream before writing or dispatching. - Every lifecycle skill has exactly one `## Work Link` section. - Every non-trivial item is an entity with a path or canonical URI. Use `lev://entity/work/workstream/<id>` for workstreams and `lev://entity/work/task/<id>` for tasks; load lane guidance through `skill://<lane>`. - Move entities forward one lifecycle state at a time; do not skip from memory directly to execution unless sufficient captured, planned or proposed context already exists. - Broad work compiles a plan in `/lev-plan`; for SDLC delivery the plan precedes its slice map and task packet. One bounded software slice may record that a plan is not required. - Workstreams are durable identity. Markdown handoffs are projections, not the canonical state. - If a command mutates files, records, tasks, or workstream state, route through the lane owner instead of freelancing. ## QA / Pentagon Gate State This table applies only when the selected overlay/task declares these gates. Non-coding work without an SDLC packet uses its domain acceptance criteria; absence of `execution.yaml` alone is not a missing gate or proposal requirement. QA, Pentagon, UltraQA, and ai-slop-cleaner are lifecycle gate overlays, not separate lanes. `/work` routes by missing gate state; lane skills own the details. | Gate state | Meaning | Route | |---|---|---| | `needs_proof_design` | Highest-risk claim, fail-closed acceptance, or owner-local test placement is unclear | `/interview` or `/lev-plan` according to scope | | `needs_proof_gates` | Applicable selected-flow node packs or task requirements, or requirement-row `check:` proof, are missing or unresolved; for a v2 task, absence of `execution.yaml.proof_gates` alone must not trigger repair | `/lev-plan` | | `needs_runtime_qa` | Declared baseline, Pentagon, UltraQA, or harness runtime checks still need execution | `/exec` | | `needs_quality_review` | Cleanup, refactor, fallback, boundary, or AI-slop risk needs ai-slop-cleaner review | `/exec` | | `needs_close_verdict` | Work is implemented but proof-gate verdicts or residual risks are not sealed | `/close` | | `proof_blocked` | A proof gate fails or cannot run safely | `/lev-plan` for contract repair or `/capture` for follow-up | ## Router ```yaml steps: - id: resolve_workstream action: Identify the active workstream or route to /ws. validation: "A workstream id is known, or /ws is the next skill." on_failure: "Do not write. Route to /ws find|resume or create a workstream." - id: classify_entity action: Name the entity, active domain, current state, target state and any applicable missing gate. validation: "Entity has path/id/uri plus current_state and target_state; proof_gate_state is required only for declared gate overlays." on_failure: "Route to /capture if it is only in conversation memory." - id: route_lane action: Select the domain-appropriate lifecycle owner; use SDLC lanes only for the software overlay. validation: "Exactly one next skill is chosen from the lane table." on_failure: "Ask one routing question or route to /prior-art for evidence." - id: enforce_work_link action: Ensure the next skill declares lane, movement, upstream, downstream, and HUD. validation: "The selected skill has a Work Link or this session is updating it." on_failure: "Use skill-builder semantics to patch the skill before relying on it." - id: emit_hud action: Report current workstream, gate, next entity, and loop state. validation: "Response ends with the inline HUD line." on_failure: "Add the HUD before ending." ``` ## Route Table | Situation | Route | |---|---| | User dumps ideas or a thread has unfiled content | `/capture` or `/dump` as `capture --deep` | | Need evidence, provenance, lineage, or duplicate detection | `/prior-art` | | Broad/multi-slice idea or design is aligned but lacks a runbook/DAG | `/lev-plan` | | Existing plan is shallow, stale, or needs source-fidelity review | `/lev-plan deepen|review` | | SDLC plan is faithful and needs a slice map or one execution packet | `skill://lev-plan` `map` or `emit <slice-id>` | | One bounded software intent is aligned and plan-not-required | `skill://lev-plan` review or `emit <slice-id>` | | Non-coding plan is sufficient for authorized execution | Domain skill or `skill://exec`; no mandatory SDLC packet | | Task has `dna.yaml` and `execution.yaml` with a verifier | `/exec` | | Task needs proof design, proof gates, runtime QA, or quality review | route by `proof_gate_state` | | Work is verified and needs sealing, learning, commit, or next recommendation | `/close` | | Session is ending, compacting, or needs a resume prompt | `/handoff` | | Workstream identity is missing, stale, split, or tangled | `/ws` | ## Work Link Template Each lifecycle skill carries one block in this shape: ```md ## <Work Link> Lifecycle lane: {Shape|Plan|Exec|Close|Router} Entity movement: `{from_state} -> {to_state}` Workstream: resolve active workstream before writes or dispatch Upstream: `{skill_or_none}` Downstream: `{skill_or_none}` Router: `/work` HUD: end with `🧬 {ws} ⚡{exec_count} 📥{capture_count} ⏸️{paused_count} ✅{done_count} | 🚦{gate}={score} | ⏭️ {next} | 🔁{loop_state}` ``` ## Templates Templates are authoring references. Copy or render them through the owning lane; do not make another skill depend on reading them at runtime. | Template | Destination | Owner | |---|---|---| | `templates/report.md` | `.lev/pm/reports/` | `/prior-art`, `/capture` | | `templates/plan.md` | `.lev/pm/plans/` | `/lev-plan` | | `templates/design.md` | `.lev/pm/designs/` | `/interview`, `/lev-plan` | | `templates/proposal.md` | `.lev/pm/proposals/` | `/lev-plan` | | `templates/spec.md` | `.lev/pm/specs/` | `/lev-plan` | | `templates/decision.md` | `.lev/pm/decisions/` | `/close` | | `templates/validation-report.md` | `.lev/pm/validation-reports/` | `/exec`, `/close` | ## Canonical Artifact Paths and Naming Use `.lev/pm/reports/`, `.lev/pm/proposals/`, `.lev/pm/designs/`, `.lev/pm/specs/`, `.lev/pm/plans/`, `.lev/pm/handoffs/`, `.lev/pm/decisions/`, `.lev/pm/validation-reports/`, and `.lev/scratch/` according to the owning lane above. Session handoff naming contract: `{YYYYMMDD}-{workstream}-{component}-{slug}-session-{N}`. ## Red Flags - "I'll just do this without a workstream." - "This is small enough to skip entity tracking." - "The next skill will figure out the lifecycle state." - "Capture can jump to propose; the slice map will preserve the broader roadmap." - "I can execute even though this only exists in chat." - "I'll add the HUD/footer later." - "The shared partial says it, so this skill does not need to." ## Rationalization Table | Excuse | Reality | |---|---| | "Work owns everything." | Work routes; lane skills own detailed protocols. | | "A handoff markdown is enough." | Workstream YAML is durable identity; markdown is projection. | | "The user asked to execute." | Execution still needs an execution-ready entity and verifier. | | "Footer file will be loaded." | HUD is inline until FlowMind skill projection exists. | | "I know the workstream." | Name it in the HUD or route to /ws. |