/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 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`
Plan	`captured	designed -> planned
Exec	`execution_ready -> executing -> verified	blocked
Close	`verified -> closed	monitoring
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

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
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:

## <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.