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.

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, /propose, /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.

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.

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 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 skill://propose.

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

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 uses /lev-plan; for SDLC delivery it precedes /propose. 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.

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

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.

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