@ahmed-g-gad/apothem 0.1.1

package/src/apothem/skills/workflow/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: "workflow"
+version: "0.1.0"
+updated: "2026-06-14"
+description: "General-purpose workflow-harnessing skill — matched when the operator states a mission via '/goal <<mission>>', asks to 'harness a workflow', 'run a multi-agent workflow', 'orchestrate agents', 'fan out and verify', 'critique and remediate', 'maximally elevate' a target, or otherwise hands off a non-trivial multi-step mission whose accomplishment benefits from genuinely-independent parallel work plus adversarial verification. Decomposes the mission, dispatches independent agents under named return contracts (non-overlapping scope, isolation where parallel writes collide, single-message parallel launch), subjects every load-bearing finding to an EXTREMELY-CRITIQUE refute-by-default verification pass (N independent critics per finding, default 3, distinct lenses — correctness/security/reproducibility/regression — survival only on non-refute majority) before it survives, is granted to identify and remediate defects beyond the literal mission (each disclosed per rules/disclosure-ledger.md), self-augments from current authoritative SOTA sources rather than memory alone, and emits a deterministic, byte-stable result. Multi-agent dispatch and continuous auto-execution are opt-in / confirmation-gated, never default-on — the canonical home for the '/goal <<mission>>' entry pattern. A single-step request that one direct tool call resolves is below this skill's threshold."
+archetype: "orchestration-template"
+userInvocable: true
+argument-hint: "[<<mission>>] [--autonomous] [--verify-panel N]"
+disable-model-invocation: true
+allowed-tools: "Read, Write, Edit, Glob, Grep, Bash, Agent, WebSearch, WebFetch, TodoWrite"
+---
+
+<!-- SPDX-License-Identifier: MIT -->
+
+## Purpose
+
+Harness a non-trivial mission into a disciplined multi-agent workflow: decompose it, dispatch genuinely-independent agents under named return contracts, subject every finding to an adversarial refute-by-default verification pass, remediate the mission plus any defect expertise reveals along the way (disclosing each amendment), and emit a deterministic result with a single recommended next move. The skill is the operator's general-purpose orchestration surface — the canonical home for the `/goal <<mission>>` entry pattern — and it honors apothem's agnostic posture: the heavy machinery engages only when the operator opts in.
+
+## Detection Signal
+
+The operator states a mission through `/goal <<mission>>`, or asks to "harness a workflow", "run a multi-agent workflow", "orchestrate agents", "fan out and verify", "critique and remediate", or "maximally elevate" a target — any non-trivial, multi-step mission whose accomplishment benefits from independent parallel work plus adversarial verification.
+
+**Falsifiable counter-signal.** A single-step request that one direct tool call resolves is below this skill's threshold — it routes to the direct tool, not the harness.
+
+## Non-Goals
+
+The skill is NOT:
+
+- **A default-on autonomy switch.** Multi-agent dispatch and continuous auto-execution engage only under `--autonomous` (or an explicit in-conversation opt-in / the profile's `enforcement` flag), per `rules/agnostic-posture.md`. A clean invocation plans the workflow and confirms before committing irreversible or outward-facing steps.
+- **A replacement for the specialized pipelines.** Plan-suite work routes to the `/plan-<stage>` cohort and the `/plan` orchestrator; audit work routes to the audit-fortress commands; research routes to `/research`. This skill harnesses general missions and dispatches those surfaces where they fit — it does not reimplement them.
+- **A memory-only operator.** Every load-bearing technical decision consults current authoritative sources (Conformity Posture below); the skill never asserts a SOTA convention from training memory alone when the live source is reachable.
+- **A silent-scope-widener.** Remediation beyond the literal mission is granted but never silent — every beyond-mission amendment is disclosed per `rules/disclosure-ledger.md`.
+
+## Foundational Stanzas
+
+The four standing surfaces every operator inherits per the canonical project voice at `AGENTS.md` plus the active harness mirror.
+
+### Refusal & Escalation
+
+REFUSE any step that exceeds the operator's stated mission AND its disclosed beyond-mission remediation grant — name what was refused, name the boundary crossed, and surface an escalation option through the structured-inquiry channel per `rules/interactive-questions.md` (canonical channel; three-segment option annotation; never free-form prose as primary input). REFUSE engaging autonomous multi-agent dispatch when the operator has not opted in. REFUSE an irreversible or outward-facing step (deletion, publish, force-push, machine-state mutation) without per-action confirmation per the destructive-op floor. When two verification agents return contradictory verdicts on the same finding, REFUSE silent reconciliation — surface both with evidence.
+
+### Output Surface
+
+Workflow outputs land at their domain-natural locations under the host project per `rules/host-discovery.md` (code at source paths; plan artifacts inside the active suite per the suite-locality invariant at `rules/context-management.md` §2.6.1). Per `rules/operational-mandates.md` CM-7, codebase artifacts carry natural domain language — zero workflow-internal or plan-internal scaffolding. NEVER write a plan artifact to a global plans directory under any harness's config root from a downstream-project context, and NEVER write to any other global-ecosystem location.
+
+### File-Authoring Contract
+
+Every NEW codebase file the workflow creates routes through `scripts/inject-header.{sh,py}` so the canonical `SPDX-License-Identifier` `MIT` banner is injected at the head in the comment family matching the filetype; the injector is idempotent and detects the variant from the byte-exact fixture at `src/apothem/schemas/authorship-header.txt`. Exempt classes are enumerated at `src/apothem/schemas/header-exceptions.txt`. Edits to existing files preserve any existing banner; the header-inject-guard hook enforces the contract at every Write / Edit.
+
+### Structured Inquiry on Ambiguity
+
+When uncertain about any of the seven authoritative-data categories per `rules/authority-inquiry.md` — identity, scope direction, preference, security, naming of public surfaces, infrastructure, version pins — and the host is silent, route the resolution through the structured-inquiry channel with the three-segment option annotation per `rules/interactive-questions.md` §3 (rationale / recommendation / default-pointer). NEVER fabricate authoritative data. Every destructive operation routes per-file through the canonical destructive-op option sets at `rules/interactive-questions.md` §6 — one invocation per file, `default-pointer: no-default: user decision required`.
+
+## Conformity Posture
+
+**Discover-don't-assume preamble (M1).** Before any substantive decision, walk the host's ratified source-of-truth files for the surface under work per `rules/host-discovery.md`; anchor verdicts to the host's actual state, never to assumed conventions.
+
+**Current-SOTA source-consultation mandate (M5).** The workflow self-augments from current authoritative sources, not memory alone, per `rules/sota-elevation.md`. The enumerated source classes — extend comprehensively beyond this list as the mission warrants:
+
+- **Official vendor documentation** for any tool, framework, platform, or harness in scope (the authoritative current API / convention / limit).
+- **Standards and specifications** — RFCs, W3C / WHATWG, language standards, ECMA, IEEE, the relevant normative spec.
+- **Peer-reviewed and authoritative references** — primary literature, official reference works, canonical texts.
+- **Current SOTA tool documentation** — the live docs of the present best-in-class tool for the task, version-pinned where behavior shifts.
+
+A SOTA claim cites at least one source class with a retrievable pointer; an unsourced "best practice" is downgraded or routed to inquiry per `rules/option-annotation.md`.
+
+**Authority inquiry surface (M5).** Per the Structured Inquiry on Ambiguity stanza; binds the seven-category catalog at `rules/authority-inquiry.md`.
+
+## Procedure
+
+Six numbered steps. Steps 3–5 engage the heavy machinery only under opt-in; step 1, 2, and 6 run on every invocation.
+
+### 1. Frame the Mission
+
+Read the mission in full. Extract intent — not literal text alone — per `rules/expertise-posture.md`. Resolve scope ambiguity through the structured-inquiry channel before dispatch. State the mission as an outcome (testable at close), and record the beyond-mission remediation grant's scope. Apply the Obvious Purge (Filter 1 per `rules/cognitive-identity.md`): discard the first approach; find the structurally superior decomposition.
+
+### 2. Decompose & Plan the Dispatch
+
+Decompose the mission into independent work-items per `rules/agent-orchestration.md`. Choose the team pattern (Research / Audit / Implementation / Generation / Quality / Documentation) and the agent type per `rules/agent-orchestration-patterns.md` §2. Assign each agent a non-overlapping scope, a named return contract (format + max size + required fields + fallback shape), and isolation where parallel writes would collide. Deploy when 3+ independent operations, multi-path exploration, heavy reads, or multi-dimension verification justify it; skip for tightly-coupled or sub-threshold work.
+
+### 3. Dispatch (opt-in gated)
+
+Under opt-in (`--autonomous` / in-conversation opt-in / profile flag), launch independent agents in waves sized to the host's reliable concurrency (size the wave to avoid throttle; cap and sequence, never burst). Without opt-in, present the dispatch plan and confirm. Honor the single-message parallel-launch invariant for genuinely independent agents; group dependent agents into waves. The main loop never duplicates work an agent is performing.
+
+### 4. EXTREMELY-CRITIQUE Adversarial Verification
+
+Every load-bearing finding faces an independent refute-by-default verification pass before it survives (the judge-panel + adversarial-verify pattern, `rules/agent-orchestration-patterns.md` §Quality patterns):
+
+- Spawn N independent critics per finding (default 3; `--verify-panel N`), each prompted to **refute** the finding and to default to "refuted" under uncertainty.
+- A finding survives only on a non-refute majority; a majority-refute kills it.
+- Where a finding can fail in more than one way, give each critic a distinct lens (correctness / security / reproducibility / regression), not N identical refuters.
+- Contradictory verdicts surface to the operator with evidence — never silently reconciled.
+
+### 5. Remediate (mission + disclosed beyond-mission)
+
+Apply the surviving findings. Remediate root causes, not symptoms. Where expertise reveals a defect beyond the literal mission, remediate it and disclose the amendment per `rules/disclosure-ledger.md` (`[Amendment]` / `[Extension]` / `[Refinement]` with cited rationale). Integrating, correctness-critical edits stay in the main loop; independent fan-out stays in the agents.
+
+### 6. Synthesize & Self-Check
+
+Collect agent results in one pass, verify mutual consistency, synthesize a compact result, and release raw agent output from active context. The procedure keeps the main thread lean: raw agent output is released after this single-pass synthesis, so only the synthesized verified findings persist in the conversation per `rules/multi-agent-workflow.md` §4. Run the fifteen-bar pre-emission gate per `rules/pre-emission-gate.md` against every emitted artifact; iterate on any failing bar until it passes. Record the attestation.
+
+## Autonomy Posture
+
+| Mode | Trigger | Behavior |
+|------|---------|----------|
+| **Planned (default)** | clean invocation | Decompose + plan + present; confirm before committing irreversible or outward-facing steps. |
+| **Autonomous** | `--autonomous`, explicit in-conversation opt-in, or the profile `enforcement` flag | Dispatch + verify + remediate + advance continuously; every irreversible / outward-facing step still per-action confirmation-gated. |
+
+Autonomy is opt-in, never the shipped default, per `rules/agnostic-posture.md`. De-enforced machinery is preserved, not removed: the opt-in path restores it intact.
+
+## Arguments
+
+- `<<mission>>` — the mission / task / requirement in natural language (the `/goal <<mission>>` entry form).
+- `--autonomous` — opt into continuous multi-agent dispatch + advancement (default: planned, confirm-before-commit).
+- `--verify-panel N` — critics per finding in the adversarial-verify pass (default: 3).
+
+## Return Contract
+
+A deterministic result surface:
+
+- The **mission outcome** (testable against the framing at step 1).
+- The **surviving (verified) findings** with evidence.
+- The **disclosure ledger** of every beyond-mission amendment.
+- The **fifteen-bar gate attestation** per `rules/pre-emission-gate.md`.
+- A single `## Recommended Next Step`.
+
+Output shape is byte-stable for identical inputs per `rules/determinism.md`; any non-determinism is declared with its source named. When an agent wave fails or returns partial coverage, the orchestrator records the coverage gap, never silently dropping the dimension.
+
+## Recommended Next Step
+
+**State your mission as `/goal <<mission>>`** (add `--autonomous` to opt into continuous multi-agent dispatch); the harness frames it, decomposes the dispatch, runs the adversarial-verify pass, and returns the verified result with a single forward move. Begin in planned mode and opt into autonomy only once the dispatch plan reads correctly.
+
+## Bindings (§0.j five-direction)
+
+- **Drives →** ● Every operator mission handed off via `/goal <<mission>>` (the skill is user-invocable; the orchestration surface for general missions). ● Every adversarial-verify pass that gates a finding before it survives. ● Every beyond-mission amendment disclosed through the ledger. ◐ The opt-in autonomy path that restores continuous multi-agent dispatch.
+- **Satisfies →** ● `CLAUDE.md` Source Layout row "workflow" (skills/ class). ● The multi-agent independent-critique / synthesis / lean-thread capability declared at `rules/multi-agent-workflow.md`. ● The deterministic-output contract at `rules/determinism.md`. ● The agnostic default-off posture at `rules/agnostic-posture.md`.
+- **Established by ↑** ● `rules/agent-orchestration.md` (the team patterns + dispatch discipline this skill orchestrates). ● `rules/agent-orchestration-patterns.md` §Quality patterns (the judge-panel + adversarial-verify pattern). ● `rules/agnostic-posture.md` (the opt-in default-off frame). ● `rules/multi-agent-workflow.md` (the rule that declares this independent-critique / synthesis / lean-thread capability available and opt-in; this skill is the procedure that realizes it).
+- **Gated by ←** ● The harness's Agent + structured-inquiry + Edit + Write + WebSearch + WebFetch tool surface. ● The operator's opt-in for autonomous dispatch. ● The destructive-op floor for irreversible / outward-facing steps.
+- **Cross-bound with ↔** ↔ `commands/workflow.md` (the `/workflow` command entry point that drives this skill). ↔ `rules/multi-agent-workflow.md` (the rule declares the independent-critique / synthesis / lean-thread capability; this skill is the procedure that realizes it — the rule names it, the skill runs it). ↔ `rules/agent-orchestration.md` + `rules/agent-orchestration-patterns.md` (the orchestration discipline). ↔ `rules/determinism.md` (the deterministic-output contract). ↔ `rules/disclosure-ledger.md` (every beyond-mission amendment recorded). ↔ `rules/agnostic-posture.md` (opt-in autonomy). ↔ `rules/interactive-questions.md` (the structured-inquiry channel + destructive-op floor). ↔ `rules/authority-inquiry.md` (the SOTA-source + seven-category inquiry catalog). ↔ `skills/projectify/SKILL.md` (sibling deterministic-SOTA elicitation skill).

package/src/apothem/statuslines/README.md

@@ -0,0 +1,26 @@
+<!-- SPDX-License-Identifier: MIT -->
+
+# statuslines
+
+> **Role.** The conformity operating-posture statusline — a single renderer that surfaces the ecosystem's operating posture (active phase pointer, sprint goal, unresolved-inquiry count) in the harness statusline.
+
+## Files
+
+| File | Purpose |
+|------|---------|
+| `render.py` | The statusline renderer. Reads the harness statusline JSON on stdin (only `workspace.project_dir`), locates the project-local `.apothem/plans/` tree (legacy `.plans/` honored as a fallback), and emits `[<phase> \| <sprint-goal> \| <N> inquiries]`. |
+| `conformity.json` | The harness statusline-config snippet — a `type: command` entry whose command invokes `render.py` through the `${HARNESS_ROOT}` token. It wires the renderer into the harness statusline hook; `render.py` never reads it. |
+| `statusline.md` | Reference documentation for the renderer's input contract, output shape, and degradation modes. |
+| `__init__.py` | Package marker. |
+
+## Operating in this folder
+
+- **`render.py` is the single renderer.** There is one statusline product, and the harness exposes one statusline slot. Changing the rendered output means editing `render.py` and updating `statusline.md` + this README in the same change-set.
+- **Harness-agnostic, project-local paths.** The plans root resolves from the `LLM_PLAN_SUITES_DIR` operator override, then the stdin payload's `workspace.project_dir` joined with `.apothem/plans/` (legacy `.plans/` as a fallback), then the working directory's `.apothem/plans/` (same legacy fallback). No harness config path is ever hardcoded — privilege no one harness.
+- **Changing the wiring:** edit `conformity.json` (the `type: command` snippet the installer ships). The harness pipes its statusline JSON to the command's stdin; the renderer consumes only `workspace.project_dir`.
+- Python follows the repo coding conventions (3.10+ syntax, `pathlib.Path`, strict-scoped typing).
+- Validate a change with `python -m apothem.conformity.gate --all .`, `python -m pytest tests/unit/test_statuslines_render.py`, and `python -m ruff check`; the renderer is in CLI/harness-adjacent scope, so run the scoped `mypy` where it applies.
+
+## Related
+
+- [`conformity/`](../conformity/) — the conformity validators whose posture this statusline surfaces.

package/src/apothem/statuslines/__init__.py

@@ -0,0 +1,20 @@
+# SPDX-License-Identifier: MIT
+
+"""Statusline renderer and conformity-posture surface.
+
+This package carries the single operator-visible statusline renderer. The
+runtime surfaces are:
+
+* ``apothem.statuslines.render`` — the renderer, invoked through
+  ``python -m apothem.statuslines.render``. The harness pipes its
+  statusline JSON payload on stdin; the renderer reads only
+  ``workspace.project_dir`` to locate the project-local plans tree, then
+  emits the operating-posture line (active phase pointer, sprint goal,
+  unresolved-inquiry count) the harness surfaces in its status bar.
+* ``conformity.json`` — the harness statusline-config snippet (a
+  ``type: command`` entry whose command invokes ``render.py`` through the
+  ``${HARNESS_ROOT}`` token). It wires the renderer into the harness's
+  statusline hook; the renderer never reads it.
+* ``statusline.md`` — the operator-facing reference Markdown documenting
+  the renderer's input contract, output shape, and degradation modes.
+"""

package/src/apothem/statuslines/conformity.json

@@ -0,0 +1,5 @@
+{
+  "type": "command",
+  "command": "python3 \"${HARNESS_ROOT}/statuslines/render.py\"",
+  "description": "Operating-posture statusline: active sprint goal, unresolved inquiry count, current phase / sub-phase pointer. Agnostic — values are read from the operating agent's working trace (the most recently-touched plan suite's PROGRESS.md), never hardcoded."
+}

package/src/apothem/statuslines/render.py

@@ -0,0 +1,334 @@
+# SPDX-License-Identifier: MIT
+
+"""Render the conformity operating-posture statusline.
+
+The statusline surfaces three values from the operating agent's working
+trace: the active sprint goal, the unresolved inquiry count, and the
+current phase / sub-phase pointer. It is agnostic — every value is
+read from the most-recently-touched plan suite's PROGRESS.md, never
+hardcoded.
+
+This is the single statusline renderer. The harness wires it through the
+``conformity.json`` statusline-config snippet (a ``type: command`` entry
+whose command invokes this module). The harness pipes its statusline
+JSON payload on stdin; the renderer consumes only ``workspace.project_dir``
+to locate the project-local plans tree, and ignores the session-context
+fields (model / cost / duration) that the harness surfaces natively.
+
+Output shape — single line on stdout:
+
+    [<phase-pointer> | <sprint-goal-truncated> | <inquiry-count> inquir(y|ies)]
+
+Separators are ASCII pipes so the statusline renders identically across
+PowerShell, bash, and IDE harness terminals regardless of code-page.
+
+Plans-root resolution (harness-agnostic, no harness path hardcoded):
+
+1. ``$LLM_PLAN_SUITES_DIR`` when set — the operator override.
+2. ``<workspace.project_dir>/.apothem/plans/`` from the stdin payload — the
+   canonical project-local plans tree per the plans-locality discipline,
+   falling back to the legacy ``<workspace.project_dir>/.plans/`` when the
+   canonical tree is absent (dual-read compatibility window).
+3. ``<cwd>/.apothem/plans/`` when no payload is supplied — the interactive
+   fallback, with the same legacy ``<cwd>/.plans/`` fallback.
+
+Degradation modes:
+
+* No plan suite under the resolved plans root → ``[no active suite]``.
+* Suite present but PROGRESS.md unparseable → goal / pointer segments omitted.
+* Sprint Goal absent in active phase's PHASE.md → goal segment omitted.
+
+The renderer never raises to stdout. Any unexpected exception is caught
+at the outermost boundary and a degraded one-line marker is emitted so
+the harness's statusline rendering never breaks.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Final
+
+from apothem.lib.data_home import plans_root
+
+# Cap on the rendered sprint-goal substring so the statusline stays
+# bounded across narrow terminal widths. PHASE.md Sprint Goal sentences
+# regularly exceed 200 characters; the truncation preserves enough
+# context for the operator to recognize the goal without dominating the
+# statusline.
+_SPRINT_GOAL_CHARLIMIT: Final[int] = 80
+
+# Cap on the active-phase pointer substring. Phase headings include
+# zero-padded numbers and kebab-case topics; 60 characters is the
+# observed upper bound across active plan suites without truncation.
+_PHASE_POINTER_CHARLIMIT: Final[int] = 60
+
+# Environment override for the plans root. When set, it wins over the
+# stdin payload's project-local resolution — the operator escape hatch.
+_PLANS_DIR_ENV: Final[str] = "LLM_PLAN_SUITES_DIR"
+
+_ACTIVE_PHASE_FIELD = re.compile(
+    r"^-\s+\*\*Active phase:\*\*\s+(.+?)(?=\s+—|\s+-\s|$)",
+    re.MULTILINE,
+)
+_PHASE_IN_PROGRESS_FIELD = re.compile(
+    r"^-\s+\*\*Phase in progress:\*\*\s+(.+?)(?=\s+—|\s+-\s|$)",
+    re.MULTILINE,
+)
+_SPRINT_GOAL_LINE = re.compile(
+    r"^>\s+\*\*Sprint Goal\.\*\*\s+(.+)$",
+    re.MULTILINE,
+)
+# Match concrete placeholders only. Payload contains no nested brackets
+# AND no ellipsis (Unicode `…` or ASCII `..`+). The negative lookaheads
+# exclude template citations such as `<USER-CONFIRM:id=<id>>`,
+# `<USER-CONFIRM:…>`, and `<USER-CONFIRM:kind=...; ...>` that appear in
+# design-source and rule prose discussing the placeholder syntax itself.
+_USER_CONFIRM_PLACEHOLDER = re.compile(r"<USER-CONFIRM:(?![^>]*(?:\.\.|…))[^<>]+>")
+
+
+@dataclass(frozen=True)
+class StatuslineParts:
+    """The three values rendered on the statusline.
+
+    Attributes:
+        phase_pointer: Active phase / sub-phase identifier, or ``None``
+            when absent.
+        sprint_goal: The active phase's Sprint Goal sentence,
+            truncated to ``_SPRINT_GOAL_CHARLIMIT``, or ``None`` when
+            absent.
+        inquiry_count: Total `<USER-CONFIRM:…>` placeholders detected
+            across the active suite's ecosystem-emitted artifacts.
+    """
+
+    phase_pointer: str | None
+    sprint_goal: str | None
+    inquiry_count: int
+
+
+def _most_recent_suite(plans_dir: Path) -> Path | None:
+    """Return the most-recently-modified suite folder under ``plans_dir``."""
+
+    if not plans_dir.is_dir():
+        return None
+    candidates = [p for p in plans_dir.iterdir() if p.is_dir()]
+    if not candidates:
+        return None
+    return max(candidates, key=lambda p: p.stat().st_mtime)
+
+
+def _extract_phase_pointer(progress_text: str) -> str | None:
+    """Extract the active-phase pointer from PROGRESS.md text."""
+
+    for pattern in (_ACTIVE_PHASE_FIELD, _PHASE_IN_PROGRESS_FIELD):
+        match = pattern.search(progress_text)
+        if match:
+            pointer = match.group(1).strip()
+            if len(pointer) > _PHASE_POINTER_CHARLIMIT:
+                pointer = pointer[: _PHASE_POINTER_CHARLIMIT - 1] + "…"
+            return pointer
+    return None
+
+
+def _extract_sprint_goal(suite_root: Path, phase_pointer: str | None) -> str | None:
+    """Read the active phase's PHASE.md and return its Sprint Goal."""
+
+    if phase_pointer is None:
+        return None
+    phase_id_match = re.match(r"Phase\s+(\d+[A-Z]?)", phase_pointer)
+    if not phase_id_match:
+        return None
+    phase_id = phase_id_match.group(1).lower()
+    phases_dir = suite_root / "phases"
+    if not phases_dir.is_dir():
+        return None
+    matches = [
+        p
+        for p in phases_dir.iterdir()
+        if p.is_dir() and p.name.startswith(f"{phase_id}-")
+    ]
+    if not matches:
+        return None
+    phase_md = matches[0] / "PHASE.md"
+    if not phase_md.is_file():
+        return None
+    try:
+        text = phase_md.read_text(encoding="utf-8")
+    except OSError:
+        return None
+    match = _SPRINT_GOAL_LINE.search(text)
+    if not match:
+        return None
+    goal = match.group(1).strip()
+    if len(goal) > _SPRINT_GOAL_CHARLIMIT:
+        goal = goal[: _SPRINT_GOAL_CHARLIMIT - 1] + "…"
+    return goal
+
+
+def _count_unresolved_inquiries(suite_root: Path) -> int:
+    """Return the count of `<USER-CONFIRM:…>` placeholders in the suite."""
+
+    total = 0
+    for path in suite_root.rglob("*.md"):
+        try:
+            text = path.read_text(encoding="utf-8")
+        except OSError:
+            continue
+        total += len(_USER_CONFIRM_PLACEHOLDER.findall(text))
+    return total
+
+
+def _parse_payload(raw: str) -> dict[str, object]:
+    """Parse the harness statusline JSON payload, tolerating malformed input."""
+
+    if not raw.strip():
+        return {}
+    try:
+        obj = json.loads(raw)
+    except (json.JSONDecodeError, ValueError):
+        return {}
+    return obj if isinstance(obj, dict) else {}
+
+
+def _read_payload() -> dict[str, object]:
+    """Read and parse the harness statusline JSON payload from stdin.
+
+    Returns an empty mapping when stdin is a terminal (interactive run with
+    no piped payload) or when the read / parse fails. The renderer then
+    falls back to the working-directory plans tree.
+    """
+
+    if sys.stdin.isatty():
+        return {}
+    try:
+        raw = sys.stdin.read()
+    except (OSError, ValueError):
+        return {}
+    return _parse_payload(raw)
+
+
+def _payload_project_dir(payload: dict[str, object]) -> str | None:
+    """Extract ``workspace.project_dir`` from the harness payload, or None."""
+
+    workspace = payload.get("workspace")
+    if isinstance(workspace, dict):
+        project_dir = workspace.get("project_dir")
+        if isinstance(project_dir, str) and project_dir:
+            return project_dir
+    return None
+
+
+def _resolve_plans_dir(payload: dict[str, object]) -> Path:
+    """Resolve the plans root, harness-agnostic and project-local.
+
+    Resolution order: the ``LLM_PLAN_SUITES_DIR`` operator override, then the
+    payload's ``workspace.project_dir`` resolved to the canonical
+    ``.apothem/plans`` tree, then the current working directory resolved the
+    same way as the interactive fallback. The canonical project-local plans
+    home is ``<project-root>/.apothem/plans``; an operator with a legacy
+    ``.plans`` tree upgrades it via ``apothem migrate-workspace``. No harness
+    config path is ever hardcoded.
+    """
+
+    override = os.environ.get(_PLANS_DIR_ENV)
+    if override:
+        return Path(override)
+    project_dir = _payload_project_dir(payload)
+    base = Path(project_dir) if project_dir else Path.cwd()
+    return plans_root(base=base)
+
+
+def gather(plans_dir: Path) -> StatuslineParts | None:
+    """Walk the plans tree at ``plans_dir`` and assemble the statusline values."""
+
+    suite = _most_recent_suite(plans_dir)
+    if suite is None:
+        return None
+    progress_md = suite / "PROGRESS.md"
+    if not progress_md.is_file():
+        return StatuslineParts(phase_pointer=None, sprint_goal=None, inquiry_count=0)
+    try:
+        progress_text = progress_md.read_text(encoding="utf-8")
+    except OSError:
+        return StatuslineParts(phase_pointer=None, sprint_goal=None, inquiry_count=0)
+    phase_pointer = _extract_phase_pointer(progress_text)
+    sprint_goal = _extract_sprint_goal(suite, phase_pointer)
+    inquiry_count = _count_unresolved_inquiries(suite)
+    return StatuslineParts(
+        phase_pointer=phase_pointer,
+        sprint_goal=sprint_goal,
+        inquiry_count=inquiry_count,
+    )
+
+
+# Transliterations applied during ASCII normalization. Each mapping
+# preserves the surrounding sentence's intent while staying within the
+# 7-bit ASCII intersection so the statusline renders the same bytes on
+# Windows console, POSIX terminals, and IDE harnesses. Keys use
+# Unicode escape sequences so the source itself is ASCII-clean.
+_ASCII_TRANSLIT: Final[dict[str, str]] = {
+    chr(0x00A7): "S",  # U+00A7 SECTION SIGN
+    chr(0x2014): "-",  # U+2014 EM DASH
+    chr(0x2013): "-",  # U+2013 EN DASH
+    chr(0x00B7): "*",  # U+00B7 MIDDLE DOT
+    chr(0x2026): "...",  # U+2026 HORIZONTAL ELLIPSIS
+    chr(0x2018): "'",  # U+2018 LEFT SINGLE QUOTATION MARK
+    chr(0x2019): "'",  # U+2019 RIGHT SINGLE QUOTATION MARK
+    chr(0x201C): '"',  # U+201C LEFT DOUBLE QUOTATION MARK
+    chr(0x201D): '"',  # U+201D RIGHT DOUBLE QUOTATION MARK
+}
+
+
+def _ascii_safe(text: str) -> str:
+    """Return an ASCII-only rendering of ``text``.
+
+    Common typographic characters get transliterated; any remaining
+    non-ASCII character is dropped. The output is safe for any
+    terminal code-page without depending on stdout reconfiguration.
+    """
+
+    for src, dst in _ASCII_TRANSLIT.items():
+        text = text.replace(src, dst)
+    return text.encode("ascii", errors="ignore").decode("ascii")
+
+
+def render(parts: StatuslineParts | None) -> str:
+    """Compose the single-line statusline string."""
+
+    if parts is None:
+        return "[no active suite]"
+    segments: list[str] = []
+    if parts.phase_pointer:
+        segments.append(_ascii_safe(parts.phase_pointer))
+    if parts.sprint_goal:
+        segments.append(_ascii_safe(parts.sprint_goal))
+    inquiry_word = "inquiry" if parts.inquiry_count == 1 else "inquiries"
+    segments.append(f"{parts.inquiry_count} {inquiry_word}")
+    if not segments:
+        return "[no readable state]"
+    return "[" + " | ".join(segments) + "]"
+
+
+def main() -> int:
+    """Print the rendered statusline to stdout. Always exits 0."""
+
+    try:
+        payload = _read_payload()
+        plans_dir = _resolve_plans_dir(payload)
+        parts = gather(plans_dir)
+        sys.stdout.write(render(parts) + "\n")
+    except Exception as exc:
+        # Outermost boundary. The harness reads stdout as the rendered
+        # statusline; never leak a traceback or non-zero exit. Emit a
+        # degraded marker naming the failure class so the operator can
+        # diagnose without losing the statusline surface.
+        sys.stdout.write(f"[statusline error: {type(exc).__name__}]\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/src/apothem/statuslines/statusline.md

@@ -0,0 +1,50 @@
+<!-- SPDX-License-Identifier: MIT -->
+
+# Statusline — Working Definition
+
+> **Role.** The single conformity operating-posture statusline, emitted at the top of every harness session. Minimal, glanceable, cross-platform; surfaces the active plan suite's operating posture and documents the input it consumes and its degradation modes.
+
+The renderer is [`render.py`](./render.py); the harness wires it in through the [`conformity.json`](./conformity.json) `type: command` snippet.
+
+## Input Contract — JSON on stdin
+
+The harness pipes a JSON object the renderer reads from stdin. The renderer consumes **one** field; every other field the harness reports (model, cost, duration, version) is ignored, because those session-context values are the harness's own native statusline territory.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `workspace.project_dir` | string | Absolute path to the project root. Joined with `.apothem/plans/` (legacy `.plans/` as a fallback) to locate the project-local plans tree. |
+
+The plans root resolves in this order:
+
+1. `LLM_PLAN_SUITES_DIR` environment variable, when set — the operator override.
+2. `<workspace.project_dir>/.apothem/plans/` from the stdin payload — the canonical project-local tree per the plans-locality discipline, with a legacy `<workspace.project_dir>/.plans/` fallback.
+3. `<cwd>/.apothem/plans/` — the interactive fallback when no payload is supplied (the legacy `<cwd>/.plans/` is honored too).
+
+No harness configuration path is ever hardcoded; the renderer privileges no one harness. An absent payload or absent field degrades to the working-directory fallback, never to a harness-specific default.
+
+## Output Contract — One Line on stdout
+
+The renderer emits exactly one line to stdout, composed from the most-recently-touched plan suite under the resolved plans root:
+
+```text
+[<phase-pointer> | <sprint-goal> | <N> inquir(y|ies)]
+```
+
+1. The active phase / sub-phase pointer, read from the suite's `PROGRESS.md`.
+2. The active phase's Sprint Goal sentence, read from its `PHASE.md` (truncated to a bounded width).
+3. The count of unresolved `<USER-CONFIRM:…>` placeholders across the suite (`inquiry` / `inquiries` pluralized).
+
+Segments that are absent are omitted; the inquiry count is always present. The rendering is plain text — no ANSI color codes, no decorative ASCII, no emojis — and is normalized to 7-bit ASCII so it renders identically across PowerShell, bash, and IDE harness terminals regardless of code-page. Glanceable, cross-platform, screen-reader-friendly.
+
+### Example Render
+
+```text
+[03A-discovery | Ship the signed release. | 2 inquiries]
+```
+
+## Degradation Modes
+
+- No plan suite under the resolved plans root → `[no active suite]`.
+- Suite present but `PROGRESS.md` unparseable → the phase / goal segments are omitted; the inquiry count still renders.
+- Sprint Goal absent in the active phase's `PHASE.md` → the goal segment is omitted.
+- Any unexpected internal error → a single degraded marker `[statusline error: <ErrorClass>]`; the renderer never raises to stdout and never exits non-zero, so the harness statusline never breaks.

package/src/apothem/templates/README.md

@@ -0,0 +1,43 @@
+<!-- SPDX-License-Identifier: MIT -->
+
+# Templates
+
+Plan-suite and ledger templates — the canonical starting shapes the planning pipeline and ledger-keeping disciplines materialize into concrete artifacts. A template is read, copied, and filled; it is never the live artifact itself.
+
+## Plan-suite indexing & traceability
+
+| Template | Purpose |
+|----------|---------|
+| [`master-index-template.md`](master-index-template.md) | Suite-root index for **medium+ tier** plan suites (≥50 phases or ≥100 spec sections / constraints per `../rules/canonical-layout.md` §7). The queryable surface a fresh session or `/plan-review` cycle reads to navigate the suite without scanning every PHASE.md linearly. |
+| [`trace-matrix-template.md`](trace-matrix-template.md) | Bidirectional traceability matrix mapping every spec requirement to the phase(s) that satisfy it and back. Closes the all-tier drift-prevention invariant; at small tier a narrative trace table substitutes. |
+
+## Per-folder documentation
+
+| Template | Purpose |
+|----------|---------|
+| [`agents-md-template.md`](agents-md-template.md) | Folder-parameterizable starting shape for a per-folder `AGENTS.md` companion per `../rules/agents-md-convention.md`. Copied into a meaningful folder beside its `README.md`; orients an agent to the folder's purpose, artifacts, conventions, and safe-operation guidance. |
+
+## `/plan-spec` discipline ledgers
+
+Deliverables of the four operational disciplines (D1–D4) plus the Phase-6 Question-Resolution Sweep audit (D5, from the separate Phase-6 ten-discipline namespace) inside [`../commands/plan-spec.md`](../commands/plan-spec.md). Each is the audit surface proving its discipline executed in full; a skeletal or sham ledger fires a gate and blocks emission.
+
+| Template | Discipline | Records |
+|----------|------------|---------|
+| [`consideration-log.md`](consideration-log.md) | D1 Meticulous Consideration | Every consideration item surfaced during the prose-to-spec transformation — directives, intentions, rationales, adjacent-domain scans, second-order consequences, contradictions. |
+| [`potency-map.md`](potency-map.md) | D2 EXTREME Potency | Every preserved prose element paired with its potent operational form. |
+| [`preservation-audit.md`](preservation-audit.md) | D3 STRICT Preservation | Per-clause verdicts at all three preservation levels — syntactic, semantic, tonal. |
+| [`expertise-gap-log.md`](expertise-gap-log.md) | D4 Extensive Expertise | Which of the seven axs of breadth applied per transformation, which were not-applicable-with-rationale, which surfaced an expertise-envelope limit. |
+| [`question-resolution-audit.md`](question-resolution-audit.md) | D5 Question-Resolution Audit | Every structured-inquiry invocation across the six mandatory gate points G0–G5 — proof no question was suppressed and no default was silent. |
+
+## Conventions
+
+- Markdown templates carry the canonical single-line SPDX license header and an explanatory preamble naming the template's consumer and the gate it feeds.
+- A template is copied and filled into a concrete artifact at the canonical layout — never edited as the live artifact in place.
+- Tier thresholds and traceability discipline are specified in `../rules/canonical-layout.md`.
+
+## Operating in this folder
+
+- **A template is never the live artifact.** It is copied and filled into a concrete artifact at the canonical layout per `../rules/canonical-layout.md`; do not edit a template in place as though it were the materialized output, and never delete the template's placeholders or guidance comments in the source-of-truth file here.
+- **Do not fork the thresholds.** Tier thresholds (which plan-suite tier materializes which template) and traceability discipline are specified in `../rules/canonical-layout.md` — do not restate or fork those thresholds here.
+- **Adding a template:** author the new shape with its SPDX header and consumer/gate preamble, then register it in the matching class table above. **Modifying a template** updates every consumer's expectations in the same change-set.
+- Validate a change with `python -m apothem.conformity.gate --all .`, `python -m pytest`, and `python -m ruff check`.