@north-light/crouter 0.3.231 → 0.3.233

package/dist/api/client.d.ts

@@ -9,7 +9,7 @@ import type { FocusDTO, RegisterFocusRequest, SetFocusPaneRequest } from './dto/
 import { type ArmCronRequest, type CancelCronQuery, type CronDTO, type CronRunDTO, type CronScopeQuery, type CronShowDTO, type ListCronsQuery, type PokeCronsResult } from './dto/crons.js';
 import type { NodeConfigPatch } from './dto/config.js';
 import type { AttachEnsureRequest, AttachEnsureResultDTO } from './dto/attach.js';
-import type { DeleteProfileRequest, DeleteProfileResultDTO, EnsureProfileRequest, ProfileDTO } from './dto/profiles.js';
+import type { DeleteProfileRequest, DeleteProfileResultDTO, EnsureProfileRequest, ProfileDTO, UpdateProfileMetadataRequest } from './dto/profiles.js';
 import type { FilePeekDTO } from './dto/files.js';
 import type { MemoryDocRefDTO } from './dto/memory.js';
 import type { ChatInventoryDTO, ProspectiveChatInventoryDTO, ProspectiveChatInventoryQuery } from './dto/chat-inventory.js';
@@ -174,6 +174,8 @@ export declare class CrtrClient {
     ensureProfile(name: string, req?: EnsureProfileRequest): Promise<ProfileDTO>;
     listProfiles(): Promise<ProfileDTO[]>;
     getProfile(name: string): Promise<ProfileDTO>;
+    /** Merge and remove entries in a profile's metadata map. */
+    updateProfileMetadata(name: string, req: UpdateProfileMetadataRequest): Promise<ProfileDTO>;
     /** Force-delete or detach one profile by exact id or unique name. */
     deleteProfile(name: string, req: DeleteProfileRequest): Promise<DeleteProfileResultDTO>;
     listModelAuth(): Promise<ModelAuthListDTO>;

package/dist/api/client.js

@@ -309,6 +309,10 @@ export class CrtrClient {
     getProfile(name) {
         return this.request('GET', routes.profile(name));
     }
+    /** Merge and remove entries in a profile's metadata map. */
+    updateProfileMetadata(name, req) {
+        return this.request('PATCH', routes.profileMetadata(name), req);
+    }
     /** Force-delete or detach one profile by exact id or unique name. */
     deleteProfile(name, req) {
         return this.request('DELETE', routes.profile(name), req);

package/dist/api/dto/canvas.d.ts

@@ -19,6 +19,8 @@ export interface AttentionItemDTO {
     cwd: string;
     /** Number of open tickets on this node. */
     count: number;
+    /** Open ticket titles for this node, newest first — one per counted ticket. */
+    subjects: string[];
 }
 /** `GET /v1/canvas/attention` result. */
 export interface AttentionDTO {
@@ -142,6 +144,10 @@ export interface HistoryReadResultDTO {
 export interface SnapshotNodeDTO {
     node_id: NodeIdDTO;
     name: string;
+    /** Caller-supplied node title, kept separate from the enriched full label. */
+    title: string;
+    /** Caller-supplied node brief, or null when absent. */
+    description: string | null;
     kind: string;
     mode: string;
     lifecycle?: string;
@@ -161,6 +167,10 @@ export interface SnapshotNodeDTO {
     last_activity?: IsoTime;
     ctx_tokens?: number;
     streaming: boolean;
+    /** Number of active background bash jobs, reported only for a live broker. */
+    jobs_active: number;
+    /** Controller node this node is durably waiting for, or null. */
+    waiting_for: string | null;
     /** The node's active fault projection (structurally a `Fault`), or null. Kept
      *  as a loose object to keep this DTO free of a `core` type import. */
     hanging: Record<string, unknown> | null;

package/dist/api/dto/common.d.ts

@@ -18,7 +18,7 @@ export type LifecycleDTO = 'terminal' | 'resident';
 /** Execution mode of a node (mirrors the runtime `Mode` union). */
 export type ModeDTO = 'base' | 'orchestrator';
 /** Why a node last stopped (mirrors the runtime `ExitIntent` union). */
-export type ExitIntentDTO = 'done' | 'refresh' | 'idle-release' | null;
+export type ExitIntentDTO = 'done' | 'refresh' | 'idle-release' | 'parked' | null;
 /** Inbox urgency tier for a delivered message (mirrors feed/inbox `InboxTier`). */
 export type InboxTierDTO = 'critical' | 'urgent' | 'normal' | 'deferred';
 /** Whether a node id is a safe single filesystem path segment. Re-declared here

package/dist/api/dto/health.d.ts

@@ -8,7 +8,8 @@ export interface HealthDTO {
     brokers_reconciled: boolean;
 }
 /** `GET /v1/status` — daemon status snapshot. Backs `crtr sys daemon status`
- *  state and the `crtr canvas dashboard` header. Versions are informational. */
+ *  state and the `crtr canvas dashboard` header. `runtime_version` is also
+ *  checked by Core's minimum-runtime capability gate. */
 export interface StatusDTO {
     daemon_pid: number;
     tick_interval_ms: number;

package/dist/api/dto/lifecycle.d.ts

@@ -4,10 +4,9 @@ export interface ReviveRequest {
     /** Resume the saved conversation (true) vs a fresh launch (false). */
     resume?: boolean;
     /** Clear the finalization latch before reviving (the `--reopen` gate). The
-     *  latch clear is a canvas write, so the gate is enforced server-side: with
-     *  `reopen:false` (default) a finalized node is REJECTED (`node_finalized`);
-     *  with `reopen:true` a node that is NOT finalized is rejected
-     *  (`not_finalized`). */
+     *  revive doorway accepts it only for a finalized node (`not_finalized`
+     *  otherwise); without it, a finalized node is rejected (`node_finalized`).
+     *  Message delivery has its own wider reopen behavior. */
     reopen?: boolean;
     /** Wake provenance: the cron whose run drove this revive (`CRTR_CRON_ID`,
      *  set by the daemon in every cron run's environment and forwarded by the

package/dist/api/dto/messages.d.ts

@@ -19,8 +19,9 @@ export interface SendMessageRequest {
     from?: NodeIdDTO | null;
     /** Revive with no inbox entry (`--fresh` → `reviveNode({ resume: false })`). */
     fresh?: boolean;
-    /** Clear a latched target's finalization latch before an immediate delivery
-     *  or `--fresh` revive (`--reopen`). Immediate only. */
+    /** Before delivery, make the target resident and clear its finalization latch
+     *  when present (`--reopen`). Accepted for both durable and interactive
+     *  delivery; `--fresh` retains its separate finalized-only gate. */
     reopen?: boolean;
     /** Hidden ambient context upserted onto the target's sidecar as a
      *  `situational` card, never visible chat (`--situational-context`).
@@ -42,8 +43,8 @@ export interface SendMessageRequest {
      *  on its one serialized frame loop — the same ordering a tmux viewer gets)
      *  instead of the durable inbox; a dormant or mid-revive target falls back to
      *  the durable inbox + revive (watcher delivers post-boot). Plain immediate
-     *  body only — rejected with fresh/reopen/situational_context/
-     *  output_schema or tier 'deferred'. Runtime cards ARE accepted: a
+     *  body only — rejected with fresh/situational_context/output_schema or tier
+     *  'deferred'. Runtime cards and reopen ARE accepted: a
      *  card-bearing send is an ordinary human send that happens to carry context,
      *  and the live deliver frame places the cards ahead of the body in one turn.
      *  Absent → durable inbox (unchanged). */

package/dist/api/dto/nodes.d.ts

@@ -33,6 +33,8 @@ export interface CreateNodeRequest {
     pin_cwd?: string;
     /** Display name (tmux window + resume picker). Defaults to the kind. */
     name?: string;
+    /** Caller-supplied short description, preserved against automatic naming. */
+    description?: string;
     parent?: NodeIdDTO | null;
     root?: boolean;
     /** Lifecycle of an independent root. Defaults to `resident`; use `terminal`

package/dist/api/dto/profiles.d.ts

@@ -23,6 +23,11 @@ export interface EnsureProfileRequest {
      *  launched under the profile as `CRTR_PROFILE_META_<KEY>` env. */
     metadata?: Record<string, string>;
 }
+/** `PATCH /v1/profiles/{name}/metadata` body. Merges `set` and removes `unset`. */
+export interface UpdateProfileMetadataRequest {
+    set?: Record<string, string>;
+    unset?: string[];
+}
 /** `DELETE /v1/profiles/{name}` body. Destructive deletion is never implicit. */
 export interface DeleteProfileRequest {
     force: boolean;

package/dist/api/routes.d.ts

@@ -93,6 +93,7 @@ export declare const routes: {
     readonly humanRequestCancel: (requestId: string) => string;
     readonly profiles: () => string;
     readonly profile: (name: string) => string;
+    readonly profileMetadata: (name: string) => string;
     readonly modelAuths: () => string;
     readonly modelAuth: (provider: string) => string;
     readonly filePeek: () => string;

package/dist/api/routes.js

@@ -124,6 +124,7 @@ export const routes = {
     // Profiles (deletion is daemon-owned because it crosses canvas state)
     profiles: () => `${V}/profiles`,
     profile: (name) => `${V}/profiles/${name}`,
+    profileMetadata: (name) => `${V}/profiles/${name}/metadata`,
     // Model auth
     modelAuths: () => `${V}/model-auth`,
     modelAuth: (provider) => `${V}/model-auth/${provider}`,

package/dist/builtin-memory/00-runtime-base/00-authoring.md

@@ -6,6 +6,8 @@ rationale: >-
 
   "Say what actually happens" exists because an approval request called a root a person had created an "attended root" — an invented category with no referent in the product, which forced Silas to halt the decision and ask what the term meant (2026-07-28). Agents coin taxonomies to compress a distinction; the reader pays by decoding a word that names nothing real.
 
+  "Ground what you report" and "Acting" exist because the Fable 5 model guidance (adopted 2026-08-22, Silas) showed that an explicit audit-against-tool-results instruction nearly eliminates fabricated status reports, and that un-steered models take unrequested actions and over-deliberate; both sections track the official wording closely on purpose — its density and operational triggers are the quality bar.
+
   The Mermaid line exists because the viewer's inline diagram affordance is otherwise invisible to an agent working from ordinary Markdown defaults.
 
   An "Identity" section is deliberately absent, and the artifacts section carries no paths. The bearings message already states the node id, the context dir's absolute path, the `$CRTR_CONTEXT_DIR` env var, the address-by-absolute-path rule, the bare-`context/` trap, and the cwd — so a layer copy was pure duplication. It was also the only per-node text in the whole system-prompt block: the preference render interpolates `$CRTR_NODE_ID`/`$CRTR_CONTEXT_DIR`, which made every node's cached prompt prefix globally unique. Keep node-specific values out of this layer; bearings is where they belong.
@@ -24,6 +26,12 @@ An artifact you write to your context dir is shared by pointer: whatever carries
 ## Living documents
 Every doc you keep — artifact, plan, findings, memory — is a living statement of what is true *now*, never a log of how it got that way. When something changes, rewrite the doc in place as if writing it fresh: fold an answer into the section it settles and delete the question, replace superseded findings, and never leave an old version beside the new one. Superseded text keeps steering whoever reads it — an audit trail in a working doc costs the next reader the very attention the doc exists to save.
 
+## Ground what you report
+Before reporting progress, audit each claim against a tool result from this session. Report only work you can point to evidence for; if something is not yet verified, say so explicitly. Report outcomes faithfully: if tests fail, say so with the output; if a step was skipped, say that; when something is done and verified, state it plainly without hedging.
+
+## Acting
+When you have enough information to act, act — do not re-derive facts already established, re-litigate a decision already made, or narrate options you will not pursue; when weighing a choice, give a recommendation, not a survey. When whoever tasked you is describing a problem or thinking out loud rather than requesting a change, the deliverable is your assessment — report your findings and stop. Before a command that changes system state (a restart, a delete, a config edit), check that the evidence supports that specific action — a signal that pattern-matches a known failure may have a different cause.
+
 ## Say what actually happens
 Everything you write — replies, reports, approval requests, artifacts, memory docs, comments — describes systems in concrete, existing product terms: the real command, the real event, the actual cause. When you need shorthand for a distinction, spell it out ("a root created by a person" vs "a root created by a cron job") instead of coining a label ("attended root"); an invented term makes the reader stop and decode a category the system does not actually have.
 

package/dist/builtin-memory/00-runtime-base/01-escalation.md

@@ -8,7 +8,7 @@ surfaces:
 ---
 
 ## When blocked, want feedback, or need the user
-Don't guess at a decision a person should make. Run `crtr human send -h` and put the question to the user through the crouter human inbox, because a question posed as prose in a reply or report pings nobody while an ask lands on their screen and pushes the answer back to your inbox. An ask blocks on a person, so spend them well: resolve what the code, a tool, or a delegate can settle, and engage when intent is genuinely ambiguous, when approaches carry real tradeoffs, when scope or direction changes, when an action is irreversible or high-risk, or when finished work needs sign-off — a whole goal costs a handful of asks, not a stream.
+Ask the user only when the work genuinely requires them: intent that stays ambiguous after you have dug, a tradeoff that is genuinely theirs, a real scope or direction change, a destructive or irreversible action, or sign-off on finished work. Settle everything the code, a tool, or a delegate can settle first — a whole goal costs a handful of asks, not a stream. Ask through the human inbox (`crtr human send -h`), then end your turn: a question posed as prose in a reply or report pings nobody, while an ask lands on their screen and its answer wakes you.
 
 ## When crtr itself misbehaves
 A `crtr` command that errors unexpectedly, hangs, churns, double-spawns, or contradicts its own `-h` is a harness bug — don't silently work around it. Run `crtr sys feedback` to report it (`-h` for how), then continue.

package/dist/builtin-memory/01-spine/00-has-manager.md

@@ -8,7 +8,7 @@ surfaces:
 ---
 
 ## Reporting up (the feed)
-You report to whoever subscribes to you (usually your parent). They see your output ONLY through explicit pushes (`crtr push -h`) — nothing is sent automatically when you stop, so narrating progress in your turn reaches no one.
+You report to whoever subscribes to you (usually your parent). They see your output ONLY through explicit pushes (`crtr push -h`) — nothing is sent automatically when you stop, so narrating progress in your turn reaches no one. Lead a push with the outcome — what happened or what you found — then the detail and artifact paths.
 
 ## Escalating
 If the work is bigger or different than your task implies, say so in a push to your managers rather than silently expanding scope.

package/dist/builtin-memory/02-turn-lifecycle/00-ending-a-turn.md

@@ -4,6 +4,8 @@ when-and-why-to-read: When a node has no immediate action because it awaits an e
 rationale: >-
   "Waiting is a way to end a turn" lived in its own ungated all-node doc until 2026-07-28. Same gate, same audience, never independently readable — so the split bought no routing and cost a stub cross-reference in runtime-base pointing at a section spliced a few hundred tokens later. It now has its own sort position as the turn-lifecycle preamble; split it again only when a section needs its own sort position, incident rationale, or independent deletion/re-gate decision.
 
+  "Never end on a promise" exists because deep into long sessions models occasionally end a turn on a text-only statement of intent without the corresponding tool call; the check-your-last-paragraph form is the operational trigger the Fable 5 guidance validated (adopted 2026-08-22, Silas).
+
   Yield applies to every node regardless of mode; promotion does not, because only the mode layers own that boundary — 04-base-worker for when a base node should promote, the kernel for how an orchestrator uses promotion — so restating it in the universal layer duplicated the base-worker text for an audience that includes nodes it does not apply to.
 lint-ignore: length
 surfaces:
@@ -19,6 +21,9 @@ When your goal is sound but your next step is blocked on something that has not
 - **For waits the runtime already knows — a child's report or the reply to your own human page — just stop.** Go dormant; the runtime wakes you when it lands. There is nothing to poll or verify, and a deadline set to "check in" on a delegate is unnecessary — children auto-wake you when they push.
 - **Schedule a wake yourself only when nothing can push to you** — recurring or scheduled standing work, or polling an external the spine can't deliver (CI, a deploy, a clock). Run `crtr cron -h` to schedule the matching bash action, or `crtr node wait deadline -h` when the desired contract is an inbox-versus-deadline race.
 
+## Never end on a promise
+Before you stop, check your last paragraph. If it is a plan, a list of next steps, or a promise about work you have not done ("I'll now…"), that is not an ending — do that work now with tool calls. End your turn only when the work is complete, you are waiting, or you are blocked on input only a person can provide.
+
 ## Yield for a fresh window
 When your context is filling but the mandate isn't done, yield: you revive fresh as the same node with the same mandate, carrying a note to your future self.
 

package/dist/builtin-memory/02-turn-lifecycle/02-resident.md

@@ -8,9 +8,11 @@ surfaces:
 ---
 
 ## Communicating with the user
-- Respond to what was actually said—don’t invent questions, concerns, or agreement.
-- Lead with substance—skip praise, validation, and conversational throat-clearing.
-- Use plain, proportionate language—cut clichés, metaphors, faux urgency, and repetition.
+- Respond to what was actually said — don't invent questions, concerns, or agreement.
+- Lead with the outcome: your first sentence answers "what happened" or "what did you find" — the thing they would ask for if they said "just give me the TLDR." Supporting detail and reasoning come after.
+- Keep replies short by being selective about what you include — drop details that don't change what the reader would do next — not by compressing into fragments, arrow chains, or coined shorthand. Readable beats short.
+- After a long working stretch, your reply is their first look at any of it: write it as a re-grounding, not a continuation of your working thread, and leave the vocabulary you built up while working behind unless you re-introduce it.
+- Use plain, proportionate language — cut praise, clichés, faux urgency, and repetition.
 
 ## How you end
 You are **resident** and interactable: you are never forced to submit a final result. Stopping is legitimate — the runtime keeps live waits wakeable and completes an unattended conversation after nothing remains to wake it. Do **not** `crtr push final` to "finish" (it would close you mid-conversation); you end by yielding or by being closed. End your turn whenever you have nothing in hand — the runtime owns what happens next.

package/dist/builtin-memory/04-orchestration-kernel.md

@@ -5,7 +5,7 @@ gate: {mode: orchestrator}
 rationale: >-
   Two observed orchestration failures set this kernel's stopping rules. A sole-writer feature lane produced a 5-deep 1:1 developer/orchestrator chain by repeatedly delegating the whole assignment; separately, the kernel's “idle capacity,” “maximum agents,” and “when in doubt, more rigor” objective helped produce review-only subtrees as large as 87 nodes and five levels deep. Coordination must optimize new evidence toward the goal rather than node count or process length.
 
-  Waiting guidance is deliberately absent: 02-turn-lifecycle/00-ending-a-turn owns waiting for every node, including the auto-wake on a child's report, so a kernel copy only duplicated it. Likewise the roadmap-curation paragraph leans on 00-runtime-base/00-authoring's "Living documents" for the fold-in/rewrite discipline and keeps only what is roadmap-specific, and memory guidance is absent because the substrate's always-present boot rendering already carries read-before-act, capture, and staleness rules for every node. Promotion guidance is absent because the promote boundary is a base-node decision 04-base-worker owns; here only the sub-orchestrator-child threshold matters, and "Delegating" carries it. User-engagement calibration is absent because 00-runtime-base/01-escalation's "When blocked" section owns it for every node, and the yield-with-unasked-question rule already lives in 02-turn-lifecycle/00-ending-a-turn; the kernel keeps only the stakeholder framing and the roadmap note about pending answers.
+  Prompt-writing guidance (outcome framing, intent context, artifact paths, report shape) is deliberately absent because `node new -h` owns it — the forced read at the spawn moment for every spawner, base and orchestrator alike; the kernel keeps only decomposition and cross-child routing. Waiting guidance is deliberately absent: 02-turn-lifecycle/00-ending-a-turn owns waiting for every node, including the auto-wake on a child's report, so a kernel copy only duplicated it. Likewise the roadmap-curation paragraph leans on 00-runtime-base/00-authoring's "Living documents" for the fold-in/rewrite discipline and keeps only what is roadmap-specific, and memory guidance is absent because the substrate's always-present boot rendering already carries read-before-act, capture, and staleness rules for every node. Promotion guidance is absent because the promote boundary is a base-node decision 04-base-worker owns; here only the sub-orchestrator-child threshold matters, and "Delegating" carries it. User-engagement calibration is absent because 00-runtime-base/01-escalation's "When blocked" section owns it for every node, and the yield-with-unasked-question rule already lives in 02-turn-lifecycle/00-ending-a-turn; the kernel keeps only the stakeholder framing and the roadmap note about pending answers.
 lint-ignore: length
 surfaces:
   - on: boot
@@ -62,7 +62,7 @@ Then advance. Reshape the phases themselves only when reality invalidates the pl
 
 ## Delegating
 
-Delegate **outcomes, not implementations** — define what needs to happen and why, give the child the context and the constraints, and let it choose how. You are the relay point for everything your children report up: when a child's task depends on an explore report, design, or spec an earlier child produced, name that file by path in the task — a child inherits only the files you point it at, so findings you hold but don't reference are lost to it. Break the goal into units each small enough for one child to finish well in one window. When a bounded unit itself contains enough independent work for worthwhile parallelism, create it directly as a sub-orchestrator (`crtr node new --kind <kind> --mode orchestrator`); when it is sequential, assign it to a base child that can yield across windows rather than relying on promotion.
+How to write a child's prompt lives on `crtr node new -h`, read at the moment you spawn; this kernel owns the split and the management. Break the goal into units each small enough for one child to finish well in one window, and route findings across children: you are the relay point for everything your children report up, so when a child's task depends on an explore report, design, or spec an earlier child produced, hand that artifact into the new task. When a bounded unit itself contains enough independent work for worthwhile parallelism, create it directly as a sub-orchestrator (`crtr node new --kind <kind> --mode orchestrator`); when it is sequential, assign it to a base child that can yield across windows rather than relying on promotion.
 
 Every child's task must be a proper subset of your goal. Handing your whole remaining assignment to one child is recursion, not delegation — it recreates you one window poorer, and repeated once per window it builds a chain of managers with no worker. When a unit cannot be split and cannot run in parallel — a sole-writer implementation, one tightly interlocked surface — it is yours: work it hands-on and yield to continue across windows; hands-on work on an unsplittable unit is orchestration done right, not a lost plot.
 

package/dist/builtin-memory/insights/capture.md

@@ -26,7 +26,8 @@ Write a small Markdown artifact under this node's absolute context directory and
 ```markdown
 # Proposed insight: <short principle name>
 
-- **destination:** <canonical name (scope) — existing doc to rewrite, new flat doc, or link into a listener or router>
+- **destination:** <canonical name (scope) — existing doc to rewrite, new flat doc, or link into a listener or router — with the neighbouring listing, so the placement is judgeable without a lookup>
+- **visibility:** <the gate and surfaces the doc will carry, or none, and why that reach is right>
 - **source:** <the episode in one line, quoting the user's pivotal words>
 
 ## Proposed durable truth
@@ -35,7 +36,7 @@ Write a small Markdown artifact under this node's absolute context directory and
 - <Another plausible formulation only when the deeper principle is uncertain.>
 ```
 
-Quote only enough of the user's words in `source` for them to judge the inference. Candidate bullets are hypotheses, not polished prose: several alternatives are allowed when the deeper principle is uncertain; do not pad, explain every bullet, or hide uncertainty in a long essay.
+`destination` and `visibility` are proposals to approve, never questions to ask: decide both and state the reason. Quote only enough of the user's words in `source` for them to judge the inference. Candidate bullets are hypotheses, not polished prose: several alternatives are allowed when the deeper principle is uncertain; do not pad, explain every bullet, or hide uncertainty in a long essay.
 
 The review is asynchronous. Continue unrelated work or wait dormant, but do not finish while this review is outstanding. An approval settles only this candidate; do not recapture it as a new insight unless the user introduces a genuinely separate principle.
 

package/dist/builtin-memory/internal/memory-loading.md

@@ -9,7 +9,7 @@ surfaces:
 
 # How memory loads
 
-Every memory doc declares its own delivery in frontmatter `surfaces` entries; the runtime never guesses. Delivery is five events, one rung per entry, document and entry gates, and structural ordering. The authoring contract (flags, routing-line craft) is `crtr memory write -h`; which scope to write to is `internal/agent-shaping`; physical paths are `internal/storage-tiers`. This doc is the mechanics between those: what actually fires, when, and in what order.
+Every memory doc declares its own delivery in frontmatter `surfaces` entries; the runtime never guesses. Delivery is six events, one rung per entry, document and entry gates, and structural ordering. The authoring contract (flags, routing-line craft) is `crtr memory write -h`; which scope to write to is `internal/agent-shaping`; physical paths are `internal/storage-tiers`. This doc is the mechanics between those: what actually fires, when, and in what order.
 
 ## Surfaces entries
 
@@ -19,7 +19,8 @@ A doc with no `surfaces` does exactly one thing: appears in its directory's list
 - **workspace-open** — first-message context when cwd/profile mounts the doc's project store. Project stores only.
 - **read** — a `read` tool call returned a matching file: path globs vs the file's absolute path and basename, `./`-anchored globs vs its path relative to the store's owning repo dir, `match-frontmatter` predicates over the read file's own YAML frontmatter.
 - **memory-read** — a `crtr memory read` resolved a matching doc: name globs vs its canonical name, `./` anchored to this doc's canonical routing anchor (a collapsed directory document anchors at its own directory name).
-- **command** — a matching shell command ran: globs vs the whole command string, `*` crossing `/`. Delivery is post-execution — right for "you are now in this territory," never for "don't run this at all."
+- **command** — a matching shell command ran: globs vs the whole command string, `*` crossing `/`. Delivery is post-execution — right for "you are now in this territory"; when the point is "don't run this at all," use `pre-command` instead.
+- **pre-command** — a matching `bash` command is about to run. When the memory has not been read yet, the command does not execute — the memory comes back as the tool result instead, and the agent re-issues the command, which then runs. Use it to guarantee a memory is seen before a sensitive action is taken. Same globs as `command`, matched at command position; `match` is required. A guardrail against the faithful-but-uninformed action, not an enforcement boundary.
 
 Nothing positional fires from where a doc happens to sit on disk — only from its declared entries and its listing.
 
@@ -49,7 +50,7 @@ At boot/first-message assembly the runtime mounts: builtin docs, the user store
 
 Each project the selected profile has a relationship with carries a `memory` value — `none`, `name`, `preview`, or `content` — and that value is the maximum rung anything in that project's stores delivers at boot and workspace-open, whatever directory the node is working in. It only lowers: an entry authored below the maximum delivers at its authored rung. `none` contributes nothing to either automatic event, so a `none` project cannot shadow a same-named doc from a wider scope — that wider doc becomes the winner. A project store the selected profile has no relationship with delivers exactly what it authored.
 
-The maximum reaches those two events and nothing else. Read, memory-read, and command entries fire at their authored rungs; directory listings, `crtr memory read`, `crtr memory find`, config resolution, and plugin discovery all see the full corpus. An explicit `crtr memory read` is itself a content delivery, so reading a capped or document-gated doc returns its whole body and records content — the upgrade path for a doc the automatic events disclosed only by name or preview. Entry gates apply to companion docs routed by the `memory-read` event, not to the deliberate read or its listings.
+The maximum reaches those two events and nothing else. Read, memory-read, command, and pre-command entries fire at their authored rungs; directory listings, `crtr memory read`, `crtr memory find`, config resolution, and plugin discovery all see the full corpus. An explicit `crtr memory read` is itself a content delivery, so reading a capped or document-gated doc returns its whole body and records content — the upgrade path for a doc the automatic events disclosed only by name or preview. Entry gates apply to companion docs routed by the `memory-read` event, not to the deliberate read or its listings.
 
 A workspace's front door is an ordinary doc carrying the entry pair `{on: workspace-open, at: content}` + `{on: read, match: "./**", at: content}` — the operating guide loads when that workspace mounts or its files are read, not in every boot catalog. `crtr memory lint` requires exactly one workspace-open content doc per profile-managed project store. Multiple mounted roots render broad-to-specific.
 

package/dist/builtin-pi-packages/pi-crtr-extensions/README.md

@@ -38,7 +38,12 @@ directory's `node_modules/`.
 | `sysprompt-window.ts` | Registers `/sysprompt`, which runs `crtr sys sysprompt --window` without injecting the prompt into context. |
 | `frontmatter-rules/` | Injects `.pi/rules/*.md` whose `when:` frontmatter matches a read markdown file. `.claude/rules` are migrated into substrate docs with read-glob `surfaces` entries via `crtr sys sync project-guidance`. Needs the `yaml` dep. See the `pi-frontmatter-rules` skill. |
 | `statusline.ts` | Custom status line. |
-| `strip-skills-docs.ts` | Trims skill docs from context. |
+
+Removing pi's self-referential prompt text (the harness identity sentence and
+the pi documentation block) is NOT done here. It runs as a canvas extension, so
+it is ordered ahead of every installed package — including the Claude
+subscription adapter, which otherwise cuts the node's own persona out of the
+system prompt along with the docs block.
 
 ## Notes
 

package/dist/clients/attach/render/diagram.js

@@ -6,11 +6,19 @@
 // viewer shows the process rather than source syntax.
 //
 // How it stays simple:
-//   • termrender renders mermaid to MONOCHROME box-drawing lines with zero ANSI
-//     escapes (verified: `--color on` output for a pure mermaid fence is
-//     byte-identical to `--color off`). So the rendered lines are safe to splice
-//     back into markdown inside a plain ``` code fence — pi's Markdown then shows
-//     them verbatim in monospace, no escape-code leakage, no re-wrapping.
+//   • The rendered lines are spliced back into markdown inside a plain ``` code
+//     fence, and pi's Markdown shows a fence body VERBATIM — no re-wrapping, and
+//     ANSI escapes pass through to the terminal unchanged. That pass-through is
+//     what the splice depends on, because mermaid output is NOT escape-free:
+//     since termrender 4.12.9 an emphasis tag in a node or edge label (`<b>`,
+//     `<strong>`, `<i>`, `<em>`) renders as a real ANSI run. Verified on screen
+//     — an emphasized label arrives bold, with its box borders still aligned.
+//   • So treat these lines as STYLED text, not plain text. termrender already
+//     sized every box off the visible glyphs, so anything here that measures,
+//     truncates, or pads a rendered line must be escape-aware or it will
+//     silently reintroduce the misalignment termrender just removed. The
+//     trailing-whitespace trim below is safe only because termrender closes a
+//     run before the cell padding that follows it.
 //   • `renderMarkdown` (crouter's sole org-wide termrender binding) is
 //     synchronous and memoized, so this is a plain string→string transform with
 //     no async swap or component lifecycle.

package/dist/clients/attach/render/page-block.d.ts

@@ -29,6 +29,5 @@ export declare class PageBlockComponent implements Component {
     private diskStamp;
     private reload;
     private compose;
-    private bodyLines;
     private footerLine;
 }

package/dist/clients/attach/render/page-block.js

@@ -14,11 +14,11 @@
 import { readFileSync, statSync } from 'node:fs';
 import { pageAwaitsResponse } from '../../../core/human/page-schema.js';
 import { projectPageDisplayMarkdown } from '../../../core/human/page-markdown.js';
+import { projectHtmlDocumentMarkdown } from '../../../core/human/page-html-markdown.js';
 import { parsePage } from '../../../core/human/page.js';
 import { pageManifestPath, pagePath, responsePath } from '../../../core/human/convention.js';
 import { pageTicketState, readTicketResult } from '../../../core/human/tickets.js';
-import { renderMarkdownBlockAwareLines } from '../../../core/termrender/termrender.js';
-import { describeSlot, tableMarkdown, terminalAnswerable } from '../../inbox/tui/slots.js';
+import { pageBodyLines } from '../../inbox/tui/page-body.js';
 import { BOLD, CYAN, DIM, GREEN, RESET, YELLOW, sanitize, singleLine, truncate, wrap } from '../../inbox/tui/ansi.js';
 /** Rows of page body shown while the block is folded; Ctrl+O expands it. */
 const FOLDED_BODY_LINES = 16;
@@ -113,7 +113,7 @@ export class PageBlockComponent {
             const manifest = parsePage(this.dir);
             const displayMarkdown = manifest.dialect === 'jsx'
                 ? projectPageDisplayMarkdown(readFileSync(pagePath(this.dir, 'jsx'), 'utf8'), manifest)
-                : '';
+                : projectHtmlDocumentMarkdown(readFileSync(pagePath(this.dir, 'html'), 'utf8'));
             const state = pageTicketState(this.dir);
             const digest = state === 'resolved' ? readTicketResult(this.dir) : null;
             this.snapshot = {
@@ -140,7 +140,7 @@ export class PageBlockComponent {
             for (const line of wrap(sanitize(snapshot.manifest.subtitle), maxW))
                 out.push(`  ${DIM}${line}${RESET}`);
         }
-        const body = this.bodyLines(snapshot.manifest, snapshot.displayMarkdown, maxW, Math.max(20, width - 4));
+        const body = pageBodyLines(snapshot.manifest, snapshot.displayMarkdown, maxW, Math.max(20, width - 4));
         if (body.length > 0) {
             out.push('');
             const shown = this.expanded || body.length <= FOLDED_BODY_LINES ? body : body.slice(0, FOLDED_BODY_LINES);
@@ -155,59 +155,6 @@ export class PageBlockComponent {
         out.push('');
         return out;
     }
-    bodyLines(manifest, displayMarkdown, maxW, paneW) {
-        const md = (text) => renderMarkdownBlockAwareLines(text, maxW, paneW);
-        if (manifest.dialect === 'html')
-            return [`${DIM}HTML page — opens in a browser surface${RESET}`];
-        const lines = displayMarkdown === '' ? [] : md(displayMarkdown);
-        let priorStep = -1;
-        for (const slot of manifest.slots) {
-            if (manifest.steps > 1 && slot.step !== priorStep) {
-                if (lines.length > 0)
-                    lines.push('');
-                lines.push(`${BOLD}Step ${slot.step + 1}/${manifest.steps}${RESET}`);
-                priorStep = slot.step;
-            }
-            if (lines.length > 0)
-                lines.push('');
-            lines.push(`${BOLD}${truncate(sanitize(singleLine(describeSlot(slot))), maxW)}${RESET}`);
-            const body = slot.config.body;
-            if (typeof body === 'string' && body !== '')
-                lines.push(...md(body));
-            if (!terminalAnswerable(slot)) {
-                lines.push(`${DIM}${sanitize(slot.kind)} — open in Northlight to answer this${RESET}`);
-                continue;
-            }
-            if (slot.kind === 'text') {
-                lines.push(...md(slot.config.initialText));
-            }
-            else if (slot.kind === 'table') {
-                lines.push(...md(tableMarkdown(slot.config)));
-            }
-            else if (slot.kind === 'cards') {
-                for (const card of slot.config.cards ?? []) {
-                    lines.push(`  • ${truncate(sanitize(singleLine(card.subtitle === undefined ? card.title : `${card.title} — ${card.subtitle}`)), Math.max(10, maxW - 4))}`);
-                    if (card.body !== undefined)
-                        for (const line of wrap(sanitize(card.body), Math.max(10, maxW - 6)))
-                            lines.push(`    ${DIM}${line}${RESET}`);
-                }
-            }
-            else if (slot.kind === 'options') {
-                for (const option of slot.config.options) {
-                    lines.push(`  • ${truncate(sanitize(singleLine(option.label)), Math.max(10, maxW - 4))}`);
-                    if (option.description !== undefined)
-                        for (const line of wrap(sanitize(option.description), Math.max(10, maxW - 6)))
-                            lines.push(`    ${DIM}${line}${RESET}`);
-                }
-            }
-            else if (slot.kind === 'chart') {
-                const config = slot.config;
-                const title = config.title ?? `${config.x ?? ''} vs ${(config.y ?? []).map((y) => y.label ?? y.field).join(', ')}`;
-                lines.push(`${DIM}chart — ${sanitize(config.kind ?? 'chart')}: ${sanitize(title)}${RESET}`);
-            }
-        }
-        return lines;
-    }
     footerLine(snapshot, maxW) {
         switch (snapshot.state) {
             case 'pending':