@quantiya/codevibe-claude-plugin 2.0.38 → 2.0.40

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/context-compaction.d.ts

@@ -45,6 +45,25 @@ export declare const SESSION_CONTEXT_SECTION_MAX_CHARS_CLASSIFY = 6000;
  * between multi-agent deliberation turns while preserving the overall budget.
  */
 export declare const SESSION_CONTEXT_SECTION_MAX_CHARS_BRAINSTORM = 4800;
+/**
+ * M7 (SHARED-CONTEXT-M7-ADDENDUM.md §3.1 "Budget") — the user-context list's
+ * budgets. Pins are placed first, newest first; messages then fill their own
+ * budget, newest first, each message's text capped with an ends-preserving
+ * cut. Implementors and the decomposer get the larger budgets (their list rides
+ * the stdin, outside the 4,800-char dispatch block); the planner's
+ * classification render and the brainstorm panel get the smaller ones inside
+ * their section, plus a message floor reserved before the hot tail.
+ */
+export declare const USER_CONTEXT_PIN_MAX_CHARS_IMPLEMENTOR = 2400;
+export declare const USER_CONTEXT_MESSAGE_MAX_CHARS_IMPLEMENTOR = 2000;
+export declare const USER_CONTEXT_PIN_MAX_CHARS_PLANNER = 1600;
+export declare const USER_CONTEXT_MESSAGE_MAX_CHARS_PLANNER = 1500;
+export declare const USER_CONTEXT_MESSAGE_FLOOR_CHARS = 600;
+export declare const USER_CONTEXT_MESSAGE_LINE_MAX_CHARS = 300;
+/** §3.2 — the implementor (and decomposer) header: the wording tested in E12. */
+export declare const USER_CONTEXT_HEADER_IMPLEMENTOR = "The user's own words from earlier in this session, oldest first: rules the shell pinned and the user's recent messages. Follow every standing rule, convention or preference they state; where two conflict, the later one wins. They take precedence over the repository context and any codebase overview below. Other requests in these messages are context only; the TASK above is what to do now.";
+/** §3.2 — the planner and panel header; the lines below it stay self-describing if trimming cuts it (E6). */
+export declare const USER_CONTEXT_HEADER_PLANNER = "The user's own words from earlier in this session, oldest first, including the latest ones shown above; where two entries conflict, the later one wins:";
 /**
  * A1f Stage-1 R1 HIGH + Stage-2 R1 (H1/M2/M3/M5) — one distilled FACT:
  *  - `body` — the source item's COMPLETE typed payload, verbatim (M3:
@@ -243,7 +262,15 @@ export declare function maybeFireCompactionSafetyValve(sessionId: string): Promi
  * `null` = the chain failed verification — fail-closed, rehydrate NOTHING
  * (the A1e projection contract).
  */
-export declare function rehydrateSessionContext(deps: {
+export declare function rehydrateSessionContext(deps: RehydrateSessionContextDeps, 
+/**
+ * M7 — receives the verified items this rehydration read, so the user list
+ * (rendered from the log, not the cache — §3.2) needs no second read.
+ */
+observe?: {
+    verifiedItems?: (items: readonly ContextItem[]) => void;
+}): Promise<RehydratedSessionContext | null>;
+export interface RehydrateSessionContextDeps {
     sessionId: string;
     role: ContextItemProjectionRole;
     clearance: ContextItemSensitivity;
@@ -253,7 +280,7 @@ export declare function rehydrateSessionContext(deps: {
      * dispatch. ABSENT (e.g. the decomposer, pre-task) → session-scoped only.
      */
     scope?: DispatchScope;
-}): Promise<RehydratedSessionContext | null>;
+}
 /**
  * Render the rehydrated session context as ONE bounded prompt section (fed
  * to `composeDispatchContextBlock`'s `renderSessionContextFn` seam —
@@ -271,6 +298,88 @@ export declare function renderRehydratedSessionContext(deps: {
     /** Classifier control state comes from the current request, not prior decisions. */
     purpose?: 'classification';
 }): Promise<string>;
+/** One live pinned rule the list may show. */
+export interface UserContextPin {
+    seq: string;
+    id: string;
+    /** `- [pinned rule] …` — redacted, on one line. */
+    line: string;
+}
+/** One earlier message the list may show. */
+export interface UserContextMessage {
+    seq: string;
+    id: string;
+    /** `- [earlier message] …` — redacted, on one line, text capped. */
+    line: string;
+}
+export interface UserContextCandidates {
+    /** Live pins, oldest first. */
+    pins: UserContextPin[];
+    /** Messages eligible for the list (after the request-part exclusion and the merge rule), oldest first. */
+    messages: UserContextMessage[];
+}
+/** A live pin for `/rules` and the revocation guard (label-permitted for the planner). */
+export interface LiveUserRule {
+    id: string;
+    seq: string;
+    text: string;
+    source: 'turn' | 'explicit';
+}
+/** True for a pinned-rule or a pin-retirement `decision` body. */
+export declare function isUserRuleBody(body: unknown): boolean;
+/** §3.1 DL-2 — every live pin, oldest first (the `/rules` numbering). */
+export declare function liveUserRules(items: readonly ContextItem[]): LiveUserRule[];
+/** The session's live pins from the VERIFIED log; `null` when the chain does not verify. */
+export declare function readLiveUserRules(sessionId: string): Promise<LiveUserRule[] | null>;
+/**
+ * §3.1 — select what the list may show for a role: the label floor
+ * (`projectItemsForRole`), live pins, and the user's own messages (human
+ * `turn` items only — never agent, conductor or panel turns). With
+ * `requestText` (implementors and the decomposer), a message the brief's
+ * request part already carries is left out. Merge rule (R2-F1): a listed
+ * message whose WHOLE text is its pin appears once, as the pin; otherwise the
+ * message and its pin both appear, ordered by `seq`. A retired pin (`/rules
+ * forget`) takes its words out of its message: a whole-text message leaves the
+ * list, and a longer message stays without the pinned sentence(s) — or leaves
+ * too when they cannot be cut out (implementation gate R1-F2) — so the rule's
+ * words stop reaching agents. Pure; exported for tests.
+ */
+export declare function selectUserContextCandidates(items: readonly ContextItem[], opts: {
+    role: ContextItemProjectionRole;
+    clearance: ContextItemSensitivity;
+    requestText?: string;
+}): UserContextCandidates;
+/**
+ * §3.1 presentation — the newest `keptPinCount` pins and `keptMessageCount`
+ * messages merged by `seq`, oldest first. Older pins that did not fit collapse
+ * into one `[N older pinned rules omitted — /rules lists them all]` line at the
+ * top; messages that did not fit become `[N earlier messages omitted]` exactly
+ * where they were, between the shown entries. Pure; exported for tests.
+ */
+export declare function presentUserContext(candidates: UserContextCandidates, keptPinCount: number, keptMessageCount: number): string[];
+/**
+ * §3.2 — the implementor (and decomposer) list from verified items: pins
+ * within 2,400 chars, then messages within 2,000, newest first, presented
+ * oldest first under the binding header. Returns '' when there is nothing to
+ * show. Pure; exported for tests.
+ */
+export declare function renderUserContextFromItems(items: readonly ContextItem[], opts: {
+    role: ContextItemProjectionRole;
+    clearance: ContextItemSensitivity;
+    requestText?: string;
+}): string;
+/**
+ * §3.2/§3.3 — the implementor's and the decomposer's user-context section,
+ * read from the VERIFIED log. `requestText` is the round's (or the
+ * decomposer's) brief. Fail-closed to '' (one warning per session) — the
+ * dispatch proceeds without it. Never throws.
+ */
+export declare function renderUserContextSection(deps: {
+    sessionId: string;
+    role: ContextItemProjectionRole;
+    clearance: ContextItemSensitivity;
+    requestText?: string;
+}): Promise<string>;
 /**
  * §6 Eviction/GC — TTL-only retention sweep of the per-session log dirs
  * under `~/.codevibe/context-items/`: a session dir whose NEWEST file mtime

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/context-items.d.ts

@@ -1,4 +1,4 @@
-import { loadContextStore, resolveContextRef, probeWorkspaceGitHead } from './context-store';
+import { loadContextStore, resolveContextRef, probeWorkspaceGitHead, probeWorkspaceTreeFingerprint } from './context-store';
 import type { StructuralSummaryGenerator, RepoSummary } from '../structural-summary/types';
 import type { Tier } from './types';
 /** AppSync's pinned blind-hold ciphertext ceiling (ASCII base64 characters). */
@@ -285,6 +285,12 @@ export interface RepoStateBody {
     summary: string;
     /** The workspace git HEAD recorded AT READ TIME (§8.3 freshness). */
     gitHead?: string;
+    /**
+     * M7 (SHARED-CONTEXT-M7-ADDENDUM.md §3.5) — the working-tree fingerprint
+     * recorded AT READ START (`probeWorkspaceTreeFingerprint`). A record without
+     * one (written before M7) never projects fresh at an unchanged HEAD.
+     */
+    worktreeFingerprint?: string;
     producedAt: string;
 }
 export type RepoStateProjection = {
@@ -337,6 +343,16 @@ export declare const NON_GIT_REPO_STATE_MAX_AGE_MS: number;
  *    error, git missing, unborn HEAD) proves nothing and borrows NOTHING:
  *    never fresh (no F5 allowance) and NO re-delegation (a re-read under a
  *    failing probe records no head → a permanent loop) — stale, no-fire.
+ *  - M7 (SHARED-CONTEXT-M7-ADDENDUM.md §3.5, DL-4) — an UNCHANGED HEAD is
+ *    necessary but no longer sufficient: Accept applies a diff without
+ *    committing, so the overview can contradict the tree while HEAD stays
+ *    put. The record's `worktreeFingerprint` must equal a fresh
+ *    `probeWorkspaceTreeFingerprint`. A differing fingerprint (applied,
+ *    uncommitted edits), a record without one (written before M7) or a
+ *    failed / timed-out probe is STALE with NO re-delegation — a re-read per
+ *    Accept would be a frontier read of the whole codebase; the overview
+ *    returns at the next commit (HEAD moves → re-read) or familiarize. Each
+ *    probe's duration is logged (the per-dispatch cost on a dirty tree).
  */
 export declare function projectRepoStateForDispatch(deps: {
     sessionId: string;
@@ -346,6 +362,8 @@ export declare function projectRepoStateForDispatch(deps: {
     onStaleRedelegate?: () => void;
     /** Test seam — defaults to the real git probe. */
     probeGitHeadFn?: typeof probeWorkspaceGitHead;
+    /** Test seam — defaults to the real working-tree fingerprint probe (M7). */
+    probeTreeFingerprintFn?: typeof probeWorkspaceTreeFingerprint;
 }): Promise<RepoStateProjection>;
 /**
  * The deterministic-emitter write path for a freshly-delegated codebase
@@ -359,6 +377,8 @@ export declare function appendRepoStateItem(deps: {
     /** The LE AgentKind that authored the read (e.g. 'CLAUDE'). */
     agentId: string;
     gitHead?: string;
+    /** M7 §3.5 — the working-tree fingerprint at read start. */
+    worktreeFingerprint?: string;
     producedAt?: string;
 }): Promise<ContextItem | null>;
 /**

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/context-store.d.ts

@@ -87,6 +87,11 @@ export interface RepoStateRecord {
     producedAt: string;
     /** The git HEAD the overview was produced at, when captured cheaply. */
     gitHead?: string;
+    /**
+     * M7 (SHARED-CONTEXT-M7-ADDENDUM.md §3.5) — the working-tree fingerprint at
+     * read start (`probeWorkspaceTreeFingerprint`). Absent on older records.
+     */
+    worktreeFingerprint?: string;
 }
 /**
  * §5.4 — `slice_selector` is FORMALLY TYPED so the writer and the
@@ -359,6 +364,45 @@ export type WorkspaceGitHeadProbe = {
  *    the sound handling, pinned by test.
  */
 export declare function probeWorkspaceGitHead(workspaceRoot: string): Promise<WorkspaceGitHeadProbe>;
+/**
+ * M7 (SHARED-CONTEXT-M7-ADDENDUM.md §3.5, DL-4) — the dirty-tree fingerprint
+ * probe outcome. `durationMs` feeds the per-dispatch log line.
+ */
+export type WorkspaceTreeFingerprintProbe = {
+    kind: 'fingerprint';
+    value: string;
+    entries: number;
+    durationMs: number;
+} | {
+    kind: 'probe-failed';
+    durationMs: number;
+};
+/** §3.5 — the whole probe's budget; running past it is a failed probe (R1-F9). */
+export declare const WORKSPACE_TREE_FINGERPRINT_TIMEOUT_MS = 3000;
+/**
+ * M7 §3.5 — a lock-free fingerprint of the working tree's applied-but-
+ * uncommitted state: SHA-256 over every entry of
+ * `git --no-optional-locks status --porcelain=v1 -z --untracked-files=all`
+ * (run with `LC_ALL=C`, from the repository root) with the `lstat` size and
+ * mtime of each listed path.
+ *  - `--no-optional-locks` never takes or rewrites `.git/index` (a plain
+ *    `git status` refreshes it — design E7);
+ *  - `--untracked-files=all` lists every untracked file on its own, so an edit
+ *    inside an untracked directory moves the value (`=normal` collapses the
+ *    directory to one entry — E7);
+ *  - the stat half catches a second edit to an already-modified file, whose
+ *    porcelain line does not change;
+ *  - a rename/copy entry's source-path field is skipped, and a listed path that
+ *    no longer exists hashes as `absent` (R1-F15).
+ * A clean tree hashes the empty string. A timeout, a git failure or a
+ * non-repository is `probe-failed`, which the freshness projection treats as
+ * stale without a re-read. Known limit: a further edit inside an already-dirty
+ * submodule does not move the value (git reports one entry for it). Never
+ * throws.
+ */
+export declare function probeWorkspaceTreeFingerprint(workspaceRoot: string, options?: {
+    timeoutMs?: number;
+}): Promise<WorkspaceTreeFingerprintProbe>;
 /**
  * Hash the generation inputs (§4.2 conjunct (d)). A `StructuralSummary` is a
  * pure function of `tree content × generation inputs`; this hashes the

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/index.d.ts

@@ -207,6 +207,16 @@ export interface RunOrchestrationShellArgs {
             agent: string;
             roundNumber: number;
         }) => Promise<string>;
+        /**
+         * M7 (SHARED-CONTEXT-M7-ADDENDUM.md §3.3) — the user's own words for every
+         * implementor round; `runOrchestrationShell` installs `renderUserContextSection`.
+         */
+        userContextFn?: (input: {
+            taskId: string;
+            agent: string;
+            roundNumber: number;
+            brief: string;
+        }) => Promise<string>;
     };
     /**
      * PHASE-589/469 W3.2 — the two-phase group-escalation decision deps, built in
@@ -676,8 +686,25 @@ export declare function routeTeamDecompose(deps: {
     /** Stage-2 R3 HIGH — the loop's durable store, so the live launch persists the retained spec + attachments. */
     durableStore?: RevertManifestStore;
 }): Promise<void>;
-/** Test seam — reset the module-level A1e composer (vitest-gated). */
+/** Test seam — reset the module-level A1e and M7 composers (vitest-gated). */
 export declare function resetDispatchContextComposerForTests(): void;
+/** Test seam — install the M7 decomposer user-context composer (vitest-gated). */
+export declare function setUserContextComposerForTests(composer: ((brief: string) => Promise<string>) | null): void;
+/**
+ * A1e §8.3 (design "Freshness" bullet) — the QUIET background re-delegation
+ * of the codebase read, fired when a `repo_state` projection finds the
+ * workspace git-HEAD diverged from the record. Mirrors `routeFamiliarize`'s
+ * frontier-delegation half but renders NOTHING (no advisory, no spinner) —
+ * it only refreshes the persisted `repo_state` (legacy record + typed
+ * ContextItem, both stamped with the HEAD probed AT READ TIME) so the NEXT
+ * projection is fresh. Best-effort: every failure is logged and dropped —
+ * a background refresh must never affect the dispatch that triggered it.
+ * Exported for tests.
+ */
+export declare function redelegateRepoStateReadQuietly(deps: {
+    args: RunOrchestrationShellArgs;
+    workspaceRoot: string;
+}): Promise<void>;
 /**
  * CP-4 §4.1 (#600) — `familiarize` desktop route: the context-priming task.
  *
@@ -1092,6 +1119,28 @@ export declare function resetTurnAuthoringStateForTests(): void;
  * on any exit path. Non-throwing (delete on a Map/Set never throws).
  */
 export declare function clearTurnAuthoringSessionState(sessionId: string): void;
+/**
+ * M7 (SHARED-CONTEXT-M7-ADDENDUM.md §3.1, DL-2) — `/rule <text>`: pin the text
+ * verbatim (capped) as a durable `user_rule` decision with source `explicit`,
+ * and return the acknowledgement once the append is durable. The fail-soft
+ * floor (no at-rest key) pins nothing and says so. Exported for tests.
+ */
+export declare function pinExplicitUserRule(sessionId: string, commandText: string): Promise<string>;
+/**
+ * M7 DL-2 — `/rules` lists every live pin, numbered oldest first; `/rules
+ * forget <n>` retires pin n with an append-only `user_rule_retired` decision
+ * whose `refs` names it and whose body carries its `seq` — identical texts share
+ * a content address, so the `seq` names this occurrence (implementation gate
+ * Stage 1 R1-F1). The renderer drops that pin and takes its words out of the
+ * message it came from (R1-F2). Reads the VERIFIED log; an unverifiable chain
+ * lists nothing. Exported for tests.
+ */
+export declare function runUserRulesCommand(sessionId: string, commandText: string): Promise<string>;
+/** What `authorTurnContextItems` authored that the turn mirror still needs. */
+export interface TurnContextAuthoringResult {
+    /** M7 — the pin acknowledgements shown this turn (dispatched and added to the delta). */
+    pinAcknowledgements: string[];
+}
 /**
  * A1f (design §6 + the A1e-deferred full-vocabulary authoring) — author this
  * turn's typed ContextItems at the ONE per-turn chokepoint: the turn mirror
@@ -1100,12 +1149,16 @@ export declare function clearTurnAuthoringSessionState(sessionId: string): void;
  * turn's conversation delta.
  *
  * Deterministic emitter-assigned labels (§4.2 — never the conductor):
- *  - human `turn` (DURABLE per Finding-2) — Stage-2 R1 H1: labeled
- *    planner/brainstorm ONLY (conversation, not task contract — §5
- *    explicitly excludes the full conversation from implementor windows;
- *    the implementor-sanctioned "answered clarifications + prior handoff
- *    turns" ride the existing brief-composition path, not this projection).
+ *  - human `turn` (DURABLE per Finding-2) — labeled planner/brainstorm AND
+ *    implementor (M7, SHARED-CONTEXT-M7-ADDENDUM.md §3.1 "Labels", DL-1
+ *    design-locked 2026-09-14, replacing Stage-2 R1 H1's planner/brainstorm-
+ *    only label): implementors receive the user's own earlier messages,
+ *    bounded and redacted, through `renderUserContextSection`; reviewer and
+ *    resolver stay out (DL-3). Nothing already written is relabelled.
  *    An answering turn carries `refs` to the question item it answers (M5).
+ *  - `decision` `{action:'user_rule'}` when the turn states a standing rule
+ *    (the M7 pin grammar) — authored after the durable human turn, `refs`
+ *    naming it, and acknowledged once durable (step 1b).
  *  - `decision` per planner-decision entry (author `conductor`; durable) —
  *    broadly visible (task-shaping, §6 distillation payload), task-scoped
  *    when the decision carries a taskId (H1 scope).
@@ -1142,7 +1195,7 @@ export declare function authorTurnContextItems(deps: {
      */
     panelOwnedThisTurn?: boolean;
     turnOwnership?: BrainstormTurnOwnership;
-}): Promise<void>;
+}): Promise<TurnContextAuthoringResult>;
 export declare function emitOrchestrationTurnMirror(deps: {
     store: OrchestrationStore;
     sessionId: string;

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/quorum-loop.d.ts

@@ -100,7 +100,7 @@ export declare function policyRejectionAdvisoryText(info: {
 /**
  * Audited-path fix (Fix 5) — select the implementor `AgentKind` for a START.
  *
- *   - An explicit `override` (from `/task --agent codex|claude`) wins, BUT only
+ *   - An explicit `override` (from `/task --agent claude|codex|antigravity`) wins, BUT only
  *     when that agent was actually detected on this host (else fail-closed to the
  *     default — we never spawn a binary the host doesn't have).
  *   - Otherwise: CLAUDE when it is among the detected agents (the documented
@@ -371,6 +371,26 @@ export interface QuorumLoopDeps {
         agent: AgentKind;
         roundNumber: number;
     }) => Promise<string>;
+    /**
+     * M7 (SHARED-CONTEXT-M7-ADDENDUM.md §3.3, design-locked 2026-09-14) — the
+     * user's own words for THIS implementor round: one chronological list of the
+     * session's pinned rules and the user's earlier messages, minus any message
+     * the round's brief already carries in its request part. Called on EVERY
+     * round (round 0, a team track's round 0, revise, continuation) with that
+     * round's brief, so a rule stated while a task runs reaches its next revise
+     * round. STDIN-only, after the brief and before the prior rationale and the
+     * repository context — never `args.brief`/`task_brief`, so reviewers and the
+     * hosted engine never see it (DL-3). Wired by `cli.ts` through the
+     * dispatch-context tap; `runOrchestrationShell` installs
+     * `renderUserContextSection`. Returns `''` for "no section". ABSENT (legacy /
+     * companion / tests) → byte-identical stdin.
+     */
+    projectUserContext?: (input: {
+        taskId: string;
+        agent: AgentKind;
+        roundNumber: number;
+        brief: string;
+    }) => Promise<string>;
     /**
      * CP-1.f LOCK RP-6 — this orchestration host's detected coding agents
      * (UPPERCASE `CLAUDE` / `CODEX` / `GEMINI`), computed ONCE by `cli.ts` via
@@ -656,6 +676,20 @@ export declare class QuorumLoop {
     /** Recovery-authored briefs keyed by task/group/index/generation authority. */
     private readonly recoveredBriefsByAuthority;
     private readonly activeBriefByTask;
+    /**
+     * P45 D1 (M7 E2E step 8, 2026-09-14) — the brief + agent of EVERY single-
+     * implementor task this loop started, keyed by task id. `activeTaskId` /
+     * `activeBrief` / `activeImplementorAgent` are the LATEST task only: when a
+     * second single task started while the first still ran (the planner routed a
+     * mid-task turn as a task), the first task's revise round was composed from
+     * the second task's request (`buildReviseBrief` fell back to `activeBrief`)
+     * and its round-0 dispatch — whose envelope names the FIRST task — would have
+     * been mis-read as a team dispatch. Round-0 spawns, revise rounds and the
+     * continuation context resolve through this map first; the singletons stay
+     * as the legacy fallback (an empty envelope task id, the test seam). Entries
+     * are removed with the task's other per-task state at its terminal cleanup.
+     */
+    private readonly singleTaskContextByTask;
     /**
      * CP-1.f revise-context fix (dogfood task 2ac68708, 2026-06-11) — the BINDING
      * user-requested changes for a task, accumulated across ALL revise rounds.
@@ -1088,7 +1122,7 @@ export declare class QuorumLoop {
      * on `startTask` rejection the active context is rolled back + the buffer
      * discarded (a buffered packet whose START failed never spawns).
      */
-    private startTaskInFlight;
+    private readonly startTasksInFlight;
     /**
      * Stage-2 r2 (Codex) FIX A — GATE_DISPATCH payloads that arrived while
      * `startTask` was in flight (single-impl early-packet race), OR (CP-12 W2.b,
@@ -1317,7 +1351,7 @@ export declare class QuorumLoop {
      * so the live WS can deliver that round-0 GATE_DISPATCH to the desktop BEFORE
      * the SDK `await` below resolves. To avoid spawning before the START is
      * confirmed (and to avoid the Stage-1 FIX-3 "drop forever" no-op that hangs the
-     * loop), we ARM the active context + set `startTaskInFlight` BEFORE the await;
+     * loop), we ARM the active context + set `startTasksInFlight` BEFORE the await;
      * an early GATE_DISPATCH is then BUFFERED (not spawned) and DRAINED here once
      * the START resolves successfully. On rejection the armed context is rolled
      * back + the buffer discarded (a buffered packet whose START failed never
@@ -2500,8 +2534,10 @@ export declare class QuorumLoop {
     recordUserNote(taskId: string, note: string): void;
     /**
      * CP-1.f revise-context fix (dogfood task 2ac68708, 2026-06-11) — build the
-     * CUMULATIVE round-N+1 revise brief from the original task brief
-     * (`activeBrief`, set at start_task), every BINDING user note recorded for
+     * CUMULATIVE round-N+1 revise brief from the original task brief (the task's
+     * OWN request — `singleTaskContextByTask` for a single task, `activeBriefByTask`
+     * for a team track; `activeBrief` only as the fallback), every BINDING user
+     * note recorded for
      * this task, and the current round's reviewer findings. The SAME brief is
      * used as the implementor stdin AND the execute-first `task_brief` rendered
      * into the reviewer prompts, so reviewers and the implementor share one

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/slash-router.d.ts

@@ -34,6 +34,14 @@ export interface SlashCommandInfo {
     name: string;
     blurb: string;
 }
+/**
+ * M7 (SHARED-CONTEXT-M7-ADDENDUM.md §3.1, DL-2) — the PENDING markers the
+ * `/rule` family returns; `handleShellUserInput` authors / reads the session's
+ * pinned rules and rewrites the output (the router stays pure — no store, no log).
+ */
+export declare const USER_RULE_PIN_PENDING = "PENDING \u2014 entrypoint pins the rule";
+export declare const USER_RULES_LIST_PENDING = "PENDING \u2014 entrypoint lists pinned rules";
+export declare const USER_RULES_FORGET_PENDING = "PENDING \u2014 entrypoint retires a pinned rule";
 /** True if `command` is a shell-exit command (`/quit` / `/exit`). */
 export declare function isExitCommand(command: string): boolean;
 /**

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/team-decompose.d.ts

@@ -176,6 +176,23 @@ export declare function appendTestSurfaceGuidance(brief: string, testSurfaces: s
  * `unknown_create_error`).
  */
 export declare function parseDecomposerResult(text: string): DecomposerResult | null;
+/**
+ * P45 D2 — why a decomposer reply did not parse, for the warn log that used to say
+ * only "unparseable" (the M7 E2E could never tell which stage rejected the reply).
+ * `preview` is the reply's head, whitespace-collapsed and secret-shape redacted
+ * (`redactSecretShapesInText`), bounded to 240 characters — never the whole text.
+ * `provider_error` names a Claude `is_error` envelope (unwrapped to '' by
+ * `unwrapClaudeJson`) so it never reads as an empty capture (Stage-1 r1 F6);
+ * `unwrapClaudeJson` gives a successful envelope with an EMPTY `.result` the same
+ * `provider_error` usage reason, so that case carries this label too (Stage-1 r2 N2).
+ */
+export declare function describeDecomposerReply(text: string, opts?: {
+    providerError?: boolean;
+}): {
+    reason: 'provider_error' | 'empty' | 'no_json_object' | 'json_parse_error' | 'schema_mismatch';
+    length: number;
+    preview: string;
+};
 export interface RunLocalDecomposerDeps {
     localExecutor: LocalExecutor;
     /** Canonicalized real working dir (the repo) — the decomposer reads the tree. */

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/user-rules.d.ts

@@ -0,0 +1,83 @@
+/** `decision` body action of a pinned rule (§3.1 "Item"). */
+export declare const USER_RULE_ACTION = "user_rule";
+/** `decision` body action retiring the pinned rule named in its `refs`. */
+export declare const USER_RULE_RETIRED_ACTION = "user_rule_retired";
+/**
+ * The roles a human turn and a pinned rule are labelled for (§3.1 "Labels"):
+ * the planner, the brainstorm panel and implementors. Reviewer and resolver
+ * are excluded everywhere (DL-3).
+ */
+export declare const USER_WORDS_VISIBLE_TO: readonly ["planner", "brainstorm", "implementor"];
+/** A pinned rule's text is capped at this many chars (ends-preserving cut). */
+export declare const USER_RULE_MAX_CHARS = 600;
+/**
+ * The label that opens a brief's background-only handoff section
+ * (`composeImplementationBrief`, index.ts). Everything before it is the brief's
+ * REQUEST PART: the request, its clarifications and the task review contract.
+ */
+export declare const WORKFLOW_HANDOFF_SECTION_LABEL = "Workflow handoff context:";
+export type PinRule = 'standing-scope' | 'rule-label' | 'revocation';
+export interface PinCapture {
+    /** The matching sentence(s), verbatim and in source order, joined by one space. */
+    text: string;
+    rules: PinRule[];
+}
+export interface PinMatchContext {
+    /** True when the session already holds a live pin — only then can a revocation pin. */
+    hasPriorPins?: boolean;
+}
+/** Split into sentences: newlines, then [.!?] followed by whitespace — not after a common abbreviation. */
+export declare function splitSentences(text: string): string[];
+/** Cap a rule's text for storage (the pin grammar's capture and `/rule` share it). */
+export declare function capUserRuleText(text: string): string;
+/**
+ * The pin grammar (§3.1 "Pinning (a)"): the standing-rule capture for one human
+ * turn, or null. Per sentence, skipping questions and fenced code; the matching
+ * sentence plus the one before it when the match has fewer than six words.
+ * Slash commands are never captured. A revocation fires only when
+ * `ctx.hasPriorPins`.
+ */
+export declare function matchPinRule(turnText: string, ctx?: PinMatchContext): PinCapture | null;
+/** Collapse every whitespace run to one space, trimmed. */
+export declare function collapseWhitespace(text: string): string;
+/** Remove a leading `@agent` mention, as the planner's prompt does. */
+export declare function stripLeadingAgentMention(text: string): string;
+/**
+ * The brief's request part (§3.1 "Which messages"): the text before its
+ * `Workflow handoff context:` section — the request itself, its clarifications
+ * and the task review contract. A brief without that section is all request.
+ */
+export declare function requestPartOf(brief: string): string;
+/**
+ * Does the brief's request part already carry this message? Exact containment
+ * after collapsing whitespace, with and without a leading `@agent` mention. A
+ * message the brief no longer carries verbatim (rewritten attachment tokens,
+ * renumbered image chips, a hard-cap cut) does not match and stays in the list
+ * as context (§3.6).
+ */
+export declare function briefRequestContainsMessage(requestPart: string, message: string): boolean;
+/**
+ * A retired pin's source message without the pinned sentence(s) (implementation
+ * gate Stage 1 R1-F2): `/rules forget` must stop the rule's words reaching
+ * agents even when the user stated it inside a longer message. The message is
+ * split into sentences after collapsing whitespace; each sentence of the pin
+ * text must equal one of them, and every equal sentence is removed. Returns null
+ * when a pin sentence is not a whole sentence of the message — a pin cut at 600
+ * chars, a sentence split around fenced code, or a rule captured from a line
+ * that broke mid-sentence, whose continuation would otherwise stay behind
+ * (Stage 1 r2 N8) — or when no letter or digit is left; the caller then leaves
+ * the whole message out.
+ */
+export declare function messageWithoutRule(message: string, ruleText: string): string | null;
+/** The placeholder for an absolute local path (§3.1 "Text"). */
+export declare const LOCAL_PATH_PLACEHOLDER = "[local path]";
+export declare function redactLocalPaths(text: string): string;
+/** Known secret shapes (core's scrubber patterns) → `[redacted secret]`, then local paths. */
+export declare function redactUserText(text: string): string;
+/** One list line's text: redacted and on one line. */
+export declare function renderUserText(text: string): string;
+/**
+ * §3.1 "Acknowledgement" — shown once the pin is durable; the same scrubbed
+ * text the agents receive.
+ */
+export declare function renderPinAcknowledgement(pinText: string): string;

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/web/fetch.d.ts

@@ -1,3 +1,5 @@
+import * as dns from 'node:dns';
+import type * as net from 'node:net';
 export type FetchFailureKind = 'blocked' | 'too_large' | 'timeout' | 'network' | 'bad_content' | 'too_many_redirects' | 'http_error';
 export declare class FetchError extends Error {
     readonly kind: FetchFailureKind;
@@ -12,6 +14,18 @@ export interface GuardedFetchOptions {
     headers?: Record<string, string>;
     allowJson?: boolean;
 }
+/** Resolve a host's records and return the frozen set of validated public IPs, or throw FetchError('blocked'). */
+export declare function resolveValidatedIps(host: string, signal?: AbortSignal, customLookup?: typeof dns.lookup): Promise<{
+    addresses: {
+        address: string;
+        family: number;
+    }[];
+}>;
+/** Build a custom `lookup` that returns ONLY from the frozen validated set (no re-resolution). */
+export declare function pinnedLookup(frozen: {
+    address: string;
+    family: number;
+}[]): net.LookupFunction;
 /**
  * Guarded GET with manual redirect following (full guard re-run per hop). Returns
  * decoded text or throws FetchError. `signal` lets the caller (Esc) abort.

package/node_modules/@quantiya/codevibe-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-core",
-  "version": "2.0.33",
+  "version": "2.0.35",
   "description": "Core library for CodeVibe plugins - shared keychain, crypto, AppSync, and auth functionality",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,9 +15,10 @@
   ],
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "emit-types": "tsc --emitDeclarationOnly",
-    "build": "rm -rf dist && npm run emit-types && esbuild src/index.ts --bundle --platform=node --target=node18 --minify --packages=external --define:__CODEVIBE_TEST_BUILD__=false --outfile=dist/index.js && esbuild src/orchestration-shell/cli.ts --bundle --platform=node --target=node18 --minify-syntax --packages=external --define:__CODEVIBE_TEST_BUILD__=false --outfile=dist/orchestration-shell/cli.js --banner:js=\"#!/usr/bin/env node\" && npm run verify-no-test-hooks",
+    "emit-types": "tsc -p tsconfig.types.json --emitDeclarationOnly",
+    "build": "rm -rf dist && npm run emit-types && esbuild src/index.ts --bundle --platform=node --target=node18 --minify --packages=external --define:__CODEVIBE_TEST_BUILD__=false --outfile=dist/index.js && esbuild src/orchestration-shell/cli.ts --bundle --platform=node --target=node18 --minify-syntax --packages=external --define:__CODEVIBE_TEST_BUILD__=false --outfile=dist/orchestration-shell/cli.js --banner:js=\"#!/usr/bin/env node\" && npm run verify-no-test-hooks && npm run verify-no-test-types",
     "verify-no-test-hooks": "if grep -ERl 'CODEVIBE_TEST_FORCE_QUOTA_FAIL|CODEVIBE_TEST_FORCE_IMPLEMENTOR_AGENT|CODEVIBE_ANCHORED_PUBLICATION_AUTHORITY_ROOT|codevibe-anchored-publications-|cv-publication-authority-vitest-|codevibe\\.test\\.publication-authority-|setPublicationAuthorityRootForTestBuild|__CODEVIBE_TEST_BUILD__|_onBeforeLinkForTesting|_onBeforeSummariesLockForTesting|__codevibe_test_on_before_link|__codevibe_test_on_before_summaries_lock' dist; then echo 'ERROR: a test-only hook leaked into a published artifact (prod-unreachability invariant)'; exit 1; fi; echo 'OK — no test-only hooks in published artifacts'",
+    "verify-no-test-types": "if find dist -type f \\( -path '*/__tests__/*' -o -name '*.test.d.ts' -o -name 'test-publication-authority-setup.d.ts' \\) | grep -q .; then echo 'verify-no-test-types: test declarations present in dist (tsconfig.types.json must exclude test sources)' >&2; exit 1; fi",
     "clean": "rm -rf dist",
     "prepublishOnly": "npm run build",
     "test": "vitest run",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-claude-plugin",
-  "version": "2.0.38",
+  "version": "2.0.40",
   "description": "Control Claude Code from your iPhone and Android — real-time sync, approve file edits, send prompts by voice. Part of CodeVibe.",
   "main": "dist/server.js",
   "codevibe": {
@@ -48,7 +48,7 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@quantiya/codevibe-core": "^2.0.33",
+    "@quantiya/codevibe-core": "^2.0.35",
     "@quantiya/quorum-core": "^1.0.1",
     "dotenv": "^16.6.1",
     "express": "^5.1.0",

package/node_modules/@quantiya/codevibe-core/dist/__tests__/cp-5-baseline-invariants.test.d.ts

@@ -1 +0,0 @@
-export {};

package/node_modules/@quantiya/codevibe-core/dist/__tests__/gate-ux-regressions.test.d.ts

@@ -1 +0,0 @@
-export {};

package/node_modules/@quantiya/codevibe-core/dist/__tests__/mobile-prompt-input.test.d.ts

@@ -1 +0,0 @@
-export {};

package/node_modules/@quantiya/codevibe-core/dist/__tests__/no-raw-control-bytes-in-source.test.d.ts

@@ -1 +0,0 @@
-export {};

package/node_modules/@quantiya/codevibe-core/dist/__tests__/prompt-parser.test.d.ts

@@ -1 +0,0 @@
-export {};