@quantiya/codevibe-claude-plugin 2.0.37 → 2.0.39

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
@@ -266,7 +276,10 @@ export { renderEntryAsLine, runLineLogFallback } from './non-tty-fallback';
 export { initInkRuntime, getInkRuntime } from './ink-runtime';
 export { reducer } from './reducer';
 export { createOrchestrationStore, type OrchestrationStore } from './store';
-export { routeBrowse, type RouteBrowseDeps } from './route-browse';
+export { routeBrowse, RETAINED_PAGE_MAX_CHARS, type RouteBrowseDeps, type RetainedBrowsePage, } from './route-browse';
+export { composeBrainstormPanelBrief, fitTextToBudget, MAX_BRAINSTORM_PAGE_CHARS, MAX_BRAINSTORM_PAGE_TOKENS, MAX_BRAINSTORM_PAGE_BYTES, } from './brainstorm-quorum';
+export { extractQueryRelevantSnippets, htmlToText } from './web/extract';
+export { validateAgyArgPrompt, AGY_ARG_PROMPT_MAX_UTF8_BYTES, } from '../agy-cli-contract';
 export type { Mode, Tier, PlannerDecision, AgentKind, PlannerHealthState, RunningTaskState, ReviewerSeatState, GateState, ExecutionEventEntry, RefusalEventEntry, BypassEventEntry, MobileEventEntry, EventStreamEntry, ConversationEntry, QueuedTask, PendingClarification, OrchestrationState, OrchestrationAction, LastModeFile, TeamState, TeamTrackEntry, TeamTrackState, TeamMergeGateStatus, LiveProgress, } from './types';
 export { formatElapsed, isSpinnerPhase, renderProgressLine, type TaskProgressEvent, type OnProgress, } from './task-progress';
 export { runDeclaredTestSurfaces, DECLARED_TEST_TIMEOUT_MS, type DeclaredTestResult, type DeclaredTestReason, type RunDeclaredTestSurfacesArgs, } from './declared-test-runner';
@@ -673,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.
  *
@@ -1089,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
@@ -1097,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).
@@ -1139,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

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

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

@@ -15,7 +15,7 @@ export interface RetainedBrowsePage {
     readAt: string;
 }
 /** Retained page text bound — the answerer caps again at render time. */
-export declare const RETAINED_PAGE_MAX_CHARS = 24000;
+export declare const RETAINED_PAGE_MAX_CHARS = 120000;
 export interface RouteBrowseDeps {
     store: OrchestrationStore;
     /** Undefined when the local model isn't installed/enabled → no-model advisory. */

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/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/planner/index.d.ts

@@ -4,4 +4,4 @@ export { PlannerCacheLayer } from './cache';
 export { PlannerHealthMachine } from './health-state';
 export { BackendPlannerClient, PlannerBudgetExceededError, PlannerTierGateRejectedError, type PlannerAppSyncTransport, type PlannerCryptoBridge, type SessionKeyResolver, type ShellEventEmit, type EmitShellEventFn, } from './client';
 export { LocalGemmaPlannerAdapter, parseLocalGemmaPlannerDecision, PlannerOutputUnparseableError, renderLocalGemmaPlannerPrompt, type LocalGemmaPlannerRunner, } from './local-gemma';
-export { parseLocalGemmaAdvisorySummary, renderLocalGemmaFamiliarizePrompt, renderLocalGemmaMultiBrowsePrompt, renderLocalGemmaBrowsePrompt, MAX_MULTI_BROWSE_TOTAL_CONTENT_CHARS, MAX_MULTI_BROWSE_RENDERED_PROMPT_CHARS, type LocalGemmaAdvisoryRunner, } from './local-advisory';
+export { parseLocalGemmaAdvisorySummary, renderLocalGemmaFamiliarizePrompt, renderLocalGemmaMultiBrowsePrompt, renderLocalGemmaBrowsePrompt, MAX_BROWSE_CONTENT_CHARS, MAX_MULTI_BROWSE_TOTAL_CONTENT_CHARS, MAX_MULTI_BROWSE_RENDERED_PROMPT_CHARS, type LocalGemmaAdvisoryRunner, } from './local-advisory';

package/node_modules/@quantiya/codevibe-core/dist/planner/local-advisory.d.ts

@@ -39,12 +39,14 @@ export interface LocalGemmaAdvisoryOptions {
      */
     think?: boolean;
 }
+export declare const MAX_RENDERED_PROMPT_CHARS = 30000;
+export declare const MAX_RENDERED_PROMPT_TOKENS = 7500;
 export declare function redactAbsoluteLocalPaths(text: string): string;
 export declare function renderLocalGemmaFamiliarizePrompt(args: {
     userPrompt: string;
     summary: StructuralSummary;
 }): string;
-export declare const MAX_BROWSE_CONTENT_CHARS = 12000;
+export declare const MAX_BROWSE_CONTENT_CHARS = 24000;
 export declare const MAX_MULTI_BROWSE_TOTAL_CONTENT_CHARS = 6000;
 /**
  * WEB-BROWSING (docs/WEB-BROWSING-DESIGN.md): build the advisory prompt for a

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

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-core",
-  "version": "2.0.32",
+  "version": "2.0.34",
   "description": "Core library for CodeVibe plugins - shared keychain, crypto, AppSync, and auth functionality",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-claude-plugin",
-  "version": "2.0.37",
+  "version": "2.0.39",
   "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.32",
+    "@quantiya/codevibe-core": "^2.0.34",
     "@quantiya/quorum-core": "^1.0.1",
     "dotenv": "^16.6.1",
     "express": "^5.1.0",