muonroi-cli 1.8.3 → 1.8.5

package/dist/src/ee/recall-ledger.d.ts

@@ -24,6 +24,15 @@ export interface RecallLedger {
     clear(id: string): boolean;
     /** Check if an id was ever cleared (fed back) in this session. Used by PIL Layer 3 to suppress re-injection. */
     wasCleared(id: string): boolean;
+    /**
+     * Check if an id is currently PENDING (recorded as unrated debt, not yet fed
+     * back). PIL Layer 3 uses this to suppress re-injecting the FULL content of a
+     * hint it already surfaced earlier this session — the hit is already in the
+     * conversation history and still listed in the feedback nudge, so repeating
+     * its body every turn is pure token waste (the "hint lặp" repetition). First
+     * sighting is injected + recorded; subsequent turns skip the body.
+     */
+    isPending(id: string): boolean;
     /** Oldest-first list of still-unrated recalls. */
     pending(): PendingRecall[];
     pendingCount(): number;

package/dist/src/ee/recall-ledger.js

@@ -45,6 +45,9 @@ export function createRecallLedger() {
         wasCleared(id) {
             return cleared.has(String(id ?? "").trim());
         },
+        isPending(id) {
+            return map.has(String(id ?? "").trim());
+        },
         pending() {
             return [...map.values()].sort((a, b) => a.ts - b.ts);
         },

package/dist/src/ee/scope.d.ts

@@ -1,4 +1,5 @@
 import type { Scope } from "./types.js";
+export declare function sanitizeRemoteUrl(remoteUrl: string): string;
 export declare function buildScope(opts: {
     cwd: string;
 }): Promise<Scope>;

package/dist/src/ee/scope.js

@@ -42,6 +42,30 @@ async function findGitRoot(start) {
     }
     return null;
 }
+export function sanitizeRemoteUrl(remoteUrl) {
+    const trimmed = remoteUrl.trim();
+    // If it starts with a scheme like http://, https://, ssh://, git:// etc.
+    if (/^[a-zA-Z0-9+-.]+:\/\//.test(trimmed)) {
+        try {
+            const parsed = new URL(trimmed);
+            if (parsed.protocol === "http:" ||
+                parsed.protocol === "https:" ||
+                parsed.protocol === "git+http:" ||
+                parsed.protocol === "git+https:") {
+                parsed.username = "";
+                parsed.password = "";
+            }
+            return parsed.toString();
+        }
+        catch {
+            // Fallback for valid scheme prefix but invalid URL syntax
+            return trimmed.replace(/^([^:]+:\/\/)[^@]+@/, "$1");
+        }
+    }
+    // Prevent parsing exceptions on SSH remotes (e.g. git@github.com:...)
+    // SCP-like SSH remotes do not start with a scheme + "://"
+    return trimmed;
+}
 export async function buildScope(opts) {
     if (cached && cachedFor === opts.cwd)
         return cached;
@@ -53,7 +77,8 @@ export async function buildScope(opts) {
     }
     const head = await fs.readFile(path.join(root, ".git", "HEAD"), "utf8").catch(() => "");
     const cfg = await fs.readFile(path.join(root, ".git", "config"), "utf8").catch(() => "");
-    const { remote } = parseGitConfig(cfg);
+    const { remote: rawRemote } = parseGitConfig(cfg);
+    const remote = rawRemote ? sanitizeRemoteUrl(rawRemote) : undefined;
     const { branch } = parseHEAD(head);
     // Ecosystem detection — check if remote matches any configured pattern
     if (remote) {

package/dist/src/ee/search.d.ts

@@ -76,6 +76,13 @@ export interface FeedbackResult {
     verdict?: string;
     reason?: string;
     error?: string;
+    /**
+     * True when the brain was unreachable/transient and the verdict was durably
+     * enqueued for later delivery instead of lost. Callers treat this as success
+     * (the agent discharged its rating) and clear their recall ledger so the
+     * mandatory-rating gate cannot loop while the brain is down.
+     */
+    queued?: boolean;
 }
 /**
  * Record an agent verdict on a recalled `[id col]` entry, byte-for-byte matching

package/dist/src/ee/search.js

@@ -173,6 +173,13 @@ export async function feedbackEE(pointId, collection, verdict, reason) {
             /* non-JSON error body — fall through to status-based handling */
         }
         if (!res.ok) {
+            // Transient server-side failures (5xx / rate limit / timeout) must not lose
+            // the verdict OR block the agent: queue it for later delivery. Hard client
+            // errors (bad collection, unknown id) are the caller's fault — surface them.
+            const transient = res.status >= 500 || res.status === 429 || res.status === 408;
+            if (transient && (await tryEnqueueFeedback(body))) {
+                return { ok: true, resolvedId: pointId, verdict: wire, reason, queued: true };
+            }
             return { ok: false, error: json?.error || text || `HTTP ${res.status}` };
         }
         const resolvedId = json?.resolvedId || pointId;
@@ -182,9 +189,26 @@ export async function feedbackEE(pointId, collection, verdict, reason) {
     catch (err) {
         const { logEeFailure, classifyEeError } = await import("../utils/ee-logger.js");
         logEeFailure("search.feedbackEE", classifyEeError(err), err);
+        // Network-level failure (brain down, socket drop) — durably queue so the
+        // verdict survives and the agent's rating gate does not loop. Only report a
+        // hard failure if even the enqueue fails.
+        if (await tryEnqueueFeedback(body)) {
+            return { ok: true, resolvedId: pointId, verdict: wire, reason, queued: true };
+        }
         return { ok: false, error: err instanceof Error ? err.message : String(err) };
     }
 }
+/** Enqueue a /api/feedback body to the offline queue; false if enqueue itself fails. */
+async function tryEnqueueFeedback(body) {
+    try {
+        const { enqueue } = await import("./offline-queue.js");
+        await enqueue({ endpoint: "/api/feedback", body, enqueuedAt: Date.now() });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Mirror a feedback verdict as a LOCAL `op:'feedback'` activity row (parity with
  * mirrorRecallLocally's `op:'recall'`). Lets the session-end nudge + forensics

package/dist/src/ee/transcript-emit.js

@@ -23,6 +23,8 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 function experienceRoot() {
+    if (process.env.MUONROI_EXPERIENCE_ROOT_OVERRIDE)
+        return process.env.MUONROI_EXPERIENCE_ROOT_OVERRIDE;
     return path.join(os.homedir(), ".experience");
 }
 function emitRoot() {

package/dist/src/ee/types.d.ts

@@ -125,6 +125,11 @@ export interface RouteModelRequest {
         projectSize?: "small" | "medium" | "large";
         filesTouched?: number;
         mode?: string;
+        turnIndex?: number;
+        messageCount?: number;
+        compactionCount?: number;
+        totalSavedTokens?: number;
+        compactionSummary?: string;
     };
     runtime?: "claude" | "gemini" | "codex" | "opencode";
 }
@@ -357,6 +362,15 @@ export interface EERecallOptions {
     /** Override per-call timeout. Defaults to 15000ms — server bounds recall at ~8s internally; allow margin for embed + 3-leg search + network. */
     timeoutMs?: number;
     signal?: AbortSignal;
+    /**
+     * Council stance/role for per-stance recall weighting (Sprint-2 item 3). The
+     * server weights the recall collections toward the knowledge this stance cares
+     * about (researcher → principles, implementer → behavioral, verifier →
+     * self-QA). Unknown/absent stance is a no-op server-side.
+     */
+    stance?: string;
+    /** Alias for stance; forwarded as body.role. Either resolves the same weights. */
+    role?: string;
 }
 export interface EEUserResponse {
     user: string;
@@ -374,6 +388,14 @@ export interface BrainProxyOptions {
     maxTokens?: number;
     /** Override the brain provider (siliconflow | ollama | openai | ...). */
     provider?: string;
+    /**
+     * Ask the server to use its stronger `brainExtractModel` (structured-extraction
+     * model) instead of the hot-path `brainModel`. Zero-hardcode by design: the client
+     * sends only this flag, the server resolves the model id from its own config + key.
+     * Used by the thin-client WhoAmI brain fallback, where the weak default model
+     * mis-spells the dim vocabulary. Ignored by servers that don't recognise it.
+     */
+    useExtractModel?: boolean;
 }
 export interface EEClient {
     health(): Promise<{

package/dist/src/ee/who-am-i-brain.d.ts

@@ -0,0 +1,35 @@
+import { type PrivacyLevel, type WhoAmIProfile } from "./who-am-i.js";
+/** Feature flag — default ON, opt out with MUONROI_WHOAMI_BRAIN=0. */
+export declare function isBrainWhoAmIEnabled(): boolean;
+/**
+ * PURE: build the classify prompt. Asks the brain to distil the retrieved rules into
+ * a strict dims JSON using only the allowed names + vocabulary. Emitting fewer dims
+ * (only the confident ones) is explicitly encouraged — downstream drops the rest.
+ */
+export declare function buildStyleClassifyPrompt(rules: string[]): string;
+/**
+ * PURE: coerce a brain reply (JSON string, fenced block, or already-parsed object)
+ * into a privacy-gated WhoAmIProfile. Reuses selectWhoAmIDims for the allowlist +
+ * confidence floor. Returns null when nothing usable survives.
+ */
+export declare function parseBrainProfile(raw: unknown, level?: PrivacyLevel): WhoAmIProfile | null;
+export interface BrainWhoAmIDeps {
+    searchByText: (text: string, collections: string[], topK: number) => Promise<Array<{
+        payload?: {
+            text?: string;
+        };
+    }>>;
+    classifyViaBrain: (prompt: string, timeoutMs?: number, options?: {
+        systemPrompt?: string;
+        responseFormat?: {
+            type: string;
+        };
+        maxTokens?: number;
+        useExtractModel?: boolean;
+    }) => Promise<string | null>;
+}
+/**
+ * Derive a WhoAmIProfile from the behavioral brain. Search the user's style rules →
+ * classify them into dims via the brain LLM → privacy-gate locally. Fail-open null.
+ */
+export declare function deriveWhoAmIFromBrain(deps: BrainWhoAmIDeps, level?: PrivacyLevel): Promise<WhoAmIProfile | null>;

package/dist/src/ee/who-am-i-brain.js

@@ -0,0 +1,220 @@
+// src/ee/who-am-i-brain.ts
+//
+// Brain-derived "Who Am I" fallback for THIN-CLIENTS.
+//
+// The device-local profile.yaml pipeline (src/ee/who-am-i.ts) is full-brain-only:
+// the EE prompt interceptor bails early on remote mode (`if (isRemoteMode()) return`),
+// no /api/profile endpoint exists, and signal-extraction from transcripts never runs
+// on a thin-client. So on a thin-client getWhoAmIProfile() is structurally always
+// null and the PIL loses every style signal.
+//
+// The user's working style IS reachable though — it lives in the `experience-behavioral`
+// brain (their own authored rules: "recommend, don't ask", "keep it concise", etc.),
+// which the runtime already queries via searchByText() over /api/search. This module
+// derives the SAME WhoAmIProfile shape from those rules so all existing PIL wiring
+// (outputStyleFromProfile, the layer4/5/6 dim reads) works unchanged.
+//
+// Design guarantees:
+//   • Agent-first (no keyword regex): the rule→dim mapping is decided by the brain LLM
+//     itself (classifyViaBrain), honouring the repo rule that classification is never
+//     regex. The only regex here is tolerant JSON extraction from the LLM's reply.
+//   • Privacy: dims are re-gated locally through selectWhoAmIDims — the positive
+//     name-allowlist + per-tier confidence floor. Brain rules are user-authored style
+//     guidance (Tang-2 equivalent), so we gate at the "standard" tier; emotional.* can
+//     never surface (not on the allowlist). This is decoupled from the EE file
+//     privacyLevel (which governs the *auto-derived* on-device profile — a different,
+//     more sensitive data source that is off by default on thin-clients).
+//   • Fail-open: any gap (no rules, classifier null, unparseable output, dep throws)
+//     returns null → the PIL keeps its own per-turn default. Never throws.
+import { selectWhoAmIDims } from "./who-am-i.js";
+const BEHAVIORAL_COLLECTION = "experience-behavioral";
+const BRAIN_TOPK = 12;
+/** Brain rules are style-level guidance → the standard tier (never emotional). */
+const BRAIN_TIER = "standard";
+/**
+ * System prompt override — REQUIRED. The EE brain proxy's default system prompt is a
+ * tier-classifier ("output ONE word: fast|balanced|premium … ignore the task content"),
+ * which actively hijacks any structured-output request → malformed JSON. Verified on the
+ * live VPS (2026-07-05): omitting this made even DeepSeek-V3 emit garbage; supplying it
+ * makes the DEFAULT server model (Qwen2.5-7B) emit clean, accurate dims JSON. We do NOT
+ * override the model/provider — that would hardcode a model id (Zero-Hardcode Rule) and
+ * cost the user's own provider; the server's default brain model + key does the work.
+ */
+const STYLE_SYSTEM_PROMPT = "You extract a developer's working-style profile from their accumulated behavioral " +
+    "rules. Follow the user message instructions EXACTLY and output ONLY the requested " +
+    "JSON object. Do not classify task complexity, do not output single words, do not " +
+    "add prose before or after the JSON.";
+/**
+ * Probe the behavioral brain for working-style rules. Free-text; the server embeds
+ * + searches Qdrant. Intentionally broad — it should surface brevity / decision /
+ * feedback / delegation / risk / conflict guidance the user has accumulated.
+ */
+const STYLE_PROBE = "the user's preferred working style: communication brevity, decision speed, " +
+    "feedback and correction style, delegation style, risk tolerance, conflict style";
+// The dims the brain may emit, with the EXACT value vocabulary. Source of truth is
+// the EE profile renderer (~/.experience/src/profile-render.js DIRECTIVES) — the same
+// values the device-local profile uses and that the PIL layers compare against
+// literally (e.g. layer4 tests delegation === "autonomous", layer6 tests
+// feedback_style === "precise-correction"). A value outside this set would populate a
+// dim that no lever reads → silently inert. Keep in lockstep with the EE enum.
+const DIM_VOCAB = {
+    "communication.brevity": ["concise", "moderate", "verbose"],
+    "communication.feedback_style": ["implicit", "precise-correction"],
+    "communication.question_style": ["comparison", "debugging", "exploratory", "directive"],
+    "personality.decision_speed": ["fast-intuitive", "measured", "deliberate"],
+    "personality.risk_tolerance": ["experimental"],
+    "personality.conflict_style": ["direct-constructive", "authoritative", "cautious"],
+    "work_patterns.energy": ["night-owl", "daytime", "mixed"],
+    "work_patterns.multitasking": ["task-switcher", "sequential-deep"],
+    "work_patterns.session_length": ["short", "medium", "long"],
+    "work_patterns.delegation_style": ["autonomous", "collaborative"],
+};
+/** Feature flag — default ON, opt out with MUONROI_WHOAMI_BRAIN=0. */
+export function isBrainWhoAmIEnabled() {
+    return process.env.MUONROI_WHOAMI_BRAIN !== "0";
+}
+/**
+ * PURE: build the classify prompt. Asks the brain to distil the retrieved rules into
+ * a strict dims JSON using only the allowed names + vocabulary. Emitting fewer dims
+ * (only the confident ones) is explicitly encouraged — downstream drops the rest.
+ */
+export function buildStyleClassifyPrompt(rules) {
+    const vocabLines = Object.entries(DIM_VOCAB)
+        .map(([name, values]) => `  "${name}": one of ${values.map((v) => `"${v}"`).join(" | ")}`)
+        .join("\n");
+    const ruleBlock = rules.length
+        ? rules.map((r, i) => `${i + 1}. ${r}`).join("\n")
+        : "(no explicit rules retrieved — infer nothing; emit an empty dimensions object)";
+    return [
+        "You classify a developer's working style from their accumulated behavioral rules.",
+        "Output ONLY a JSON object of the form:",
+        '{"dimensions": {"<dim.name>": {"value": "<allowed value>", "confidence": 0.0-1.0, "sampleCount": <int>}}}',
+        "",
+        "Allowed dimensions and their vocabulary (use these names/values EXACTLY):",
+        vocabLines,
+        "",
+        "Rules:",
+        "- Include a dimension ONLY when the rules give clear evidence for it.",
+        "- Omit anything uncertain — a small, confident object beats a complete guess.",
+        "- confidence reflects how strongly the rules support the value; sampleCount = how many rules back it.",
+        "- Never invent dimension names or values outside the vocabulary above.",
+        "",
+        "Behavioral rules:",
+        ruleBlock,
+    ].join("\n");
+}
+/** Tolerantly extract the first balanced JSON object from an LLM reply. */
+function extractJsonObject(text) {
+    const start = text.indexOf("{");
+    if (start === -1)
+        return null;
+    let depth = 0;
+    let inStr = false;
+    let esc = false;
+    for (let i = start; i < text.length; i++) {
+        const ch = text[i];
+        if (inStr) {
+            if (esc)
+                esc = false;
+            else if (ch === "\\")
+                esc = true;
+            else if (ch === '"')
+                inStr = false;
+            continue;
+        }
+        if (ch === '"')
+            inStr = true;
+        else if (ch === "{")
+            depth++;
+        else if (ch === "}") {
+            depth--;
+            if (depth === 0)
+                return text.slice(start, i + 1);
+        }
+    }
+    return null;
+}
+/**
+ * PURE: coerce a brain reply (JSON string, fenced block, or already-parsed object)
+ * into a privacy-gated WhoAmIProfile. Reuses selectWhoAmIDims for the allowlist +
+ * confidence floor. Returns null when nothing usable survives.
+ */
+export function parseBrainProfile(raw, level = BRAIN_TIER) {
+    let obj = raw;
+    if (typeof raw === "string") {
+        const json = extractJsonObject(raw);
+        if (!json)
+            return null;
+        try {
+            obj = JSON.parse(json);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!obj || typeof obj !== "object")
+        return null;
+    const gated = selectWhoAmIDims(obj, level);
+    // Value validation — the name allowlist in selectWhoAmIDims does NOT check the VALUE,
+    // and weaker brain models mis-spell the vocabulary (verified on the live VPS:
+    // Qwen2.5-7B emitted "precice-correction"). An off-vocab value populates a dim that
+    // the PIL layers — which compare literally — can never fire on, so it's worse than
+    // absent (looks set, does nothing). Drop any value not in DIM_VOCAB[name].
+    const dims = {};
+    for (const [name, dim] of Object.entries(gated)) {
+        const vocab = DIM_VOCAB[name];
+        if (vocab && !vocab.includes(dim.value))
+            continue;
+        dims[name] = dim;
+    }
+    if (Object.keys(dims).length === 0)
+        return null;
+    return { level, dims };
+}
+/**
+ * Off the hot path (fire-and-forget boot warm), so a wide budget. The server's
+ * brainExtractModel is a REASONING model (deepseek-v4-flash) and the who-am-i prompt is large
+ * (12 retrieved rules + the full dim-vocabulary schema), so the think+emit cycle runs ~10-15s
+ * — verified live that a 15s cap intermittently truncated to a timeout/null. 25s clears the
+ * tail; the cost is nil because this never blocks anything (background warm).
+ */
+const BRAIN_CLASSIFY_TIMEOUT_MS = 25000;
+/**
+ * The dims JSON is tiny (~200 tokens), but the server's extract model (deepseek-v4-flash) is a
+ * REASONING model — its thinking tokens count against this same budget (landing in a separate
+ * reasoning_content field, not the JSON). A tight cap let the reasoning consume the budget and
+ * truncate the actual JSON to empty → intermittent null profiles. Give thinking ample headroom
+ * so the dims JSON always survives; extra tokens are only spent when the model reasons, and
+ * this is an off-hot-path boot warm.
+ */
+const BRAIN_CLASSIFY_MAX_TOKENS = 3000;
+/**
+ * Derive a WhoAmIProfile from the behavioral brain. Search the user's style rules →
+ * classify them into dims via the brain LLM → privacy-gate locally. Fail-open null.
+ */
+export async function deriveWhoAmIFromBrain(deps, level = BRAIN_TIER) {
+    try {
+        const points = await deps.searchByText(STYLE_PROBE, [BEHAVIORAL_COLLECTION], BRAIN_TOPK);
+        const rules = points
+            .map((p) => (typeof p.payload?.text === "string" ? p.payload.text.trim() : ""))
+            .filter((t) => t.length > 0);
+        if (rules.length === 0)
+            return null;
+        const reply = await deps.classifyViaBrain(buildStyleClassifyPrompt(rules), BRAIN_CLASSIFY_TIMEOUT_MS, {
+            systemPrompt: STYLE_SYSTEM_PROMPT,
+            responseFormat: { type: "json_object" },
+            maxTokens: BRAIN_CLASSIFY_MAX_TOKENS,
+            // Structured multi-dim extraction needs the server's stronger brainExtractModel;
+            // the hot-path model mis-spells the vocabulary (verified on the live VPS).
+            useExtractModel: true,
+        });
+        if (!reply)
+            return null;
+        return parseBrainProfile(reply, level);
+    }
+    catch {
+        // Fail-open — a degraded brain must never break the PIL hot path.
+        return null;
+    }
+}
+//# sourceMappingURL=who-am-i-brain.js.map

package/dist/src/ee/who-am-i.d.ts

@@ -10,13 +10,13 @@ export interface WhoAmIProfile {
     level: PrivacyLevel;
     dims: Partial<Record<WhoAmIDimName, WhoAmIDim>>;
 }
-interface RawDim {
+export interface RawDim {
     value: string | null;
     confidence?: number;
     sampleCount?: number;
     samples?: number;
 }
-interface RawProfile {
+export interface RawProfile {
     dimensions?: Record<string, RawDim>;
 }
 /**
@@ -38,4 +38,11 @@ export declare function outputStyleFromProfile(profile: WhoAmIProfile | null): O
 export declare function getWhoAmIProfile(): WhoAmIProfile | null;
 /** Clear the cache — test-only / after a known profile change. */
 export declare function resetWhoAmICache(): void;
-export {};
+/**
+ * Prime the per-process cache with an externally-derived profile (e.g. the
+ * thin-client brain fallback in who-am-i-brain.ts, wired via the bridge). Only
+ * overwrites when the device-local read produced nothing (`_cache` is null/unset)
+ * so a real on-device profile always wins over a brain-derived one. No-op when a
+ * device-local profile is already loaded.
+ */
+export declare function primeWhoAmICache(profile: WhoAmIProfile | null): void;

package/dist/src/ee/who-am-i.js

@@ -110,6 +110,18 @@ export function getWhoAmIProfile() {
 export function resetWhoAmICache() {
     _cache = undefined;
 }
+/**
+ * Prime the per-process cache with an externally-derived profile (e.g. the
+ * thin-client brain fallback in who-am-i-brain.ts, wired via the bridge). Only
+ * overwrites when the device-local read produced nothing (`_cache` is null/unset)
+ * so a real on-device profile always wins over a brain-derived one. No-op when a
+ * device-local profile is already loaded.
+ */
+export function primeWhoAmICache(profile) {
+    if (_cache)
+        return;
+    _cache = profile;
+}
 function loadWhoAmIProfile() {
     try {
         const req = createRequire(import.meta.url);

package/dist/src/ee/workflow-event.d.ts

@@ -0,0 +1,48 @@
+/**
+ * src/ee/workflow-event.ts
+ *
+ * Part C/D client for the EE `/api/workflow-event` write-during-execution
+ * channel (added in experience-engine Part D). Lets the council workflow persist
+ * experience MID-RUN — per-round debate outcomes, sprint results, decisions,
+ * mistakes — into the `workflow_*` collections, so a later run (or a later
+ * sprint in the SAME run) can recall it.
+ *
+ * Contract with the two Kill findings from the plan review:
+ *   - Kill #7: on a 404 (endpoint disabled / older server) DROP the event — do
+ *     NOT enqueue. Queuing 404s head-of-line-poisons the offline queue against a
+ *     server that will never accept them.
+ *   - Kill #4/#5: writes are fire-and-forget and off the critical path. Recall of
+ *     these hot entries stays gated on the server side (tier:"intra-session").
+ *
+ * On a transient network failure the event IS enqueued to the offline queue so
+ * a later drain retries it. Never throws; never blocks the workflow.
+ */
+import { enqueue } from "./offline-queue.js";
+export type WorkflowEventKind = "council-debate" | "sprint-execution" | "decision" | "mistake";
+export interface WorkflowEventPayload {
+    kind: WorkflowEventKind;
+    /** Run/phase reference, e.g. `runs/<runId>` or `runs/<runId>#sprint-3`. */
+    phaseRef: string;
+    sessionId?: string;
+    /** Short embeddable summary; falls back to a derived string server-side. */
+    text?: string;
+    /** Arbitrary structured detail persisted alongside the entry. */
+    payload?: Record<string, unknown>;
+}
+export interface FireWorkflowEventOpts {
+    baseUrl?: string;
+    authToken?: string;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    /** Test seam: override the offline-queue enqueue. */
+    enqueueImpl?: typeof enqueue;
+}
+/**
+ * POST a workflow event. Returns `true` when the server accepted it, `false`
+ * otherwise (dropped on 404, enqueued on network error). Never throws.
+ */
+export declare function fireWorkflowEvent(payload: WorkflowEventPayload, opts?: FireWorkflowEventOpts): Promise<boolean>;
+/** Fire-and-forget wrapper — never throws, never blocks the workflow. */
+export declare function fireAndForgetWorkflowEvent(payload: WorkflowEventPayload, opts?: FireWorkflowEventOpts): void;
+/** Test-only: reset the once-per-process warning latch. */
+export declare function _resetWorkflowEventState(): void;

package/dist/src/ee/workflow-event.js

@@ -0,0 +1,81 @@
+/**
+ * src/ee/workflow-event.ts
+ *
+ * Part C/D client for the EE `/api/workflow-event` write-during-execution
+ * channel (added in experience-engine Part D). Lets the council workflow persist
+ * experience MID-RUN — per-round debate outcomes, sprint results, decisions,
+ * mistakes — into the `workflow_*` collections, so a later run (or a later
+ * sprint in the SAME run) can recall it.
+ *
+ * Contract with the two Kill findings from the plan review:
+ *   - Kill #7: on a 404 (endpoint disabled / older server) DROP the event — do
+ *     NOT enqueue. Queuing 404s head-of-line-poisons the offline queue against a
+ *     server that will never accept them.
+ *   - Kill #4/#5: writes are fire-and-forget and off the critical path. Recall of
+ *     these hot entries stays gated on the server side (tier:"intra-session").
+ *
+ * On a transient network failure the event IS enqueued to the offline queue so
+ * a later drain retries it. Never throws; never blocks the workflow.
+ */
+import { classifyEeError, logEeFailure } from "../utils/ee-logger.js";
+import { getCachedAuthToken, getCachedServerBaseUrl } from "./auth.js";
+import { enqueue } from "./offline-queue.js";
+const DEFAULT_BASE = "http://localhost:8082";
+const DEFAULT_TIMEOUT_MS = 3000;
+const ENDPOINT = "/api/workflow-event";
+let _warnedOnce = false;
+/**
+ * POST a workflow event. Returns `true` when the server accepted it, `false`
+ * otherwise (dropped on 404, enqueued on network error). Never throws.
+ */
+export async function fireWorkflowEvent(payload, opts = {}) {
+    const baseUrl = opts.baseUrl ?? getCachedServerBaseUrl() ?? DEFAULT_BASE;
+    const authToken = opts.authToken ?? getCachedAuthToken() ?? undefined;
+    const f = opts.fetchImpl ?? fetch;
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const doEnqueue = opts.enqueueImpl ?? enqueue;
+    const headers = { "Content-Type": "application/json" };
+    if (authToken)
+        headers.Authorization = `Bearer ${authToken}`;
+    try {
+        const resp = await f(`${baseUrl}${ENDPOINT}`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (resp.ok)
+            return true;
+        // 404 = endpoint disabled or older server → DROP (Kill #7: never queue 404s).
+        if (resp.status === 404)
+            return false;
+        // Other non-OK (5xx, etc.) → treat like a transient failure: enqueue.
+        await doEnqueue({ endpoint: ENDPOINT, body: payload, enqueuedAt: Date.now() }).catch(() => { });
+        if (!_warnedOnce) {
+            _warnedOnce = true;
+            console.warn(`[ee] workflow-event non-OK ${resp.status}; queued (silenced after first warning)`);
+        }
+        return false;
+    }
+    catch (err) {
+        // Network error / timeout → enqueue for later drain.
+        await doEnqueue({ endpoint: ENDPOINT, body: payload, enqueuedAt: Date.now() }).catch(() => { });
+        if (!_warnedOnce) {
+            _warnedOnce = true;
+            console.warn(`[ee] workflow-event failed: ${err.message}; queued (silenced after first warning)`);
+        }
+        return false;
+    }
+}
+/** Fire-and-forget wrapper — never throws, never blocks the workflow. */
+export function fireAndForgetWorkflowEvent(payload, opts = {}) {
+    void fireWorkflowEvent(payload, opts).catch((err) => {
+        logEeFailure("workflow-event.fireAndForgetWorkflowEvent", classifyEeError(err), err);
+        /* swallow */
+    });
+}
+/** Test-only: reset the once-per-process warning latch. */
+export function _resetWorkflowEventState() {
+    _warnedOnce = false;
+}
+//# sourceMappingURL=workflow-event.js.map

package/dist/src/flow/compaction/compress.d.ts

@@ -4,7 +4,7 @@
  * Serializes messages, extracts preserved blocks, compresses if over budget,
  * then restores preserved blocks into the output.
  */
-import type { ModelMessage } from "ai";
+import { type ModelMessage } from "ai";
 import { type PreservedBlock } from "./preserve.js";
 export interface CompressResult {
     summary: string;
@@ -17,6 +17,6 @@ export interface CompressResult {
  * 1. Serialize messages via serializeConversation().
  * 2. Extract preserved blocks.
  * 3. If under budget, return as-is (with preserved blocks restored).
- * 4. If over budget, truncate/compress and restore preserved blocks.
+ * 4. If over budget, compress via LLM (if provider given) or truncate, and restore blocks.
  */
-export declare function compressChat(messages: ModelMessage[], _systemPrompt: string, tokenBudget: number, _provider?: unknown, _modelId?: string): Promise<CompressResult>;
+export declare function compressChat(messages: ModelMessage[], _systemPrompt: string, tokenBudget: number, provider?: unknown, modelId?: string, customInstructions?: string): Promise<CompressResult>;