pi-continual-harness 0.17.0 → 0.18.0

package/README.md

@@ -46,7 +46,18 @@ leaving offline and storage to the packages that already do them well.
 pi install npm:pi-continual-harness
 ```
 
-Or drop `src/index.ts` into `~/.pi/agent/extensions/`.
+The npm package ships **precompiled** (`dist/`): pi loads a thin entry
+(`dist/entry.js`) that registers hooks, commands, and tool schemas in
+milliseconds, then dynamic-imports each feature module only when its event
+first fires. Measured marginal startup cost: **~30ms** (was ~0.8s when pi
+had to jiti-transpile the whole TypeScript graph every launch — issue #36).
+
+From a source checkout instead:
+
+```
+npm run build
+pi -e ./dist/entry.js
+```
 
 ## Usage
 

package/dist/auto-refine.d.ts

@@ -0,0 +1,55 @@
+import type { ExtensionAPI, ExtensionContext, TurnEndEvent, TurnEndEventResult } from "@earendil-works/pi-coding-agent";
+import { type HarnessConfig } from "./config.js";
+export { turnEndedBadly } from "./cadence.js";
+/** Test hook: reset internal counter. */
+export declare function resetAutoRefine(): void;
+/**
+ * Decide whether to auto-refine this turn. Side-effectful: the first observed
+ * completed turn seeds the baseline (no refine then); every completed turn
+ * after it advances the count, and each fired refine resets it (which also
+ * prevents the refine turn itself from immediately re-triggering).
+ * Aborted/error turns are inert: they neither seed nor advance the count —
+ * the cadence counts completed turns of work, never raw turn indices, so an
+ * aborted turn in between cannot shorten the window.
+ */
+export declare function evaluateAutoRefine(config: HarnessConfig, outcome?: string): boolean;
+/** The boundary draft custom type for auto-refine steering messages. */
+export declare const AUTO_REFINE_ENTRY = "harness.auto-refine-request";
+/** Build the boundary draft carrying a steering message. Pure — testable. */
+export declare function buildRefineDraft(steeringMessage: string): {
+    type: "custom_message";
+    customType: string;
+    content: string;
+    display: boolean;
+};
+/** Structural slice of pi's ProjectedSessionEntry (sourceEntry + messages). */
+export interface ProjectedLike {
+    sourceEntry?: {
+        type?: string;
+        customType?: string;
+        id?: string;
+    };
+    messages?: unknown[];
+}
+/** A context_edit boundary draft (pi ≥ 0.87): omit one entry from future
+ *  provider context — raw history, usage, and UI history stay untouched. */
+export interface OmissionDraft {
+    type: "context_edit";
+    targetId: string;
+    replacement: null;
+}
+/**
+ * Context-edit drafts omitting every LIVE prior auto-refine request from
+ * future provider context (pi ≥ 0.87 ContextEditEntry). Invariant: at most
+ * ONE auto-refine request is ever model-visible — the newest. Already-omitted
+ * drafts surface in the projection with empty `messages` and are skipped, so
+ * the operation is idempotent and never stacks redundant edits. Raw history
+ * (and the HTML export) keeps every draft: /tree rollback still applies.
+ */
+export declare function buildOmissionDrafts(projected: Iterable<ProjectedLike>): OmissionDraft[];
+/** turn_end handler — run /refine on the configured cadence. Returns the
+ *  boundary continuation when a steering draft lands (pi ≥ 0.87). Exported
+ *  so the thin entry (entry.ts) can delegate via dynamic import (issue #36). */
+export declare function handleAutoRefineTurnEnd(pi: ExtensionAPI, event: TurnEndEvent, ctx: ExtensionContext): Promise<TurnEndEventResult | void>;
+/** Subscribe to turn_end and run /refine on the configured cadence. */
+export declare function registerAutoRefine(pi: ExtensionAPI): void;

package/{src/auto-refine.ts → dist/auto-refine.js}

@@ -34,25 +34,19 @@
 // It stays visible: it notifies before firing, and the boundary draft (and the
 // gate decision) appear in the transcript. The decision logic is factored into
 // evaluateAutoRefine() so it is unit-testable without a live pi runtime.
-
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { DEFAULT_AUTO_EVERY_TURNS, type HarnessConfig, loadConfig } from "./config.js";
+import { DEFAULT_AUTO_EVERY_TURNS, loadConfig } from "./config.js";
 import { runRefine, gatherEvidence, DEFAULT_LOOKBACK_TURNS } from "./refine.js";
 import { buildClassify, buildGateRequest, gateDecision } from "./classify.js";
 import { makeTurnCadence } from "./cadence.js";
-
 // turnEndedBadly's canonical home is cadence.ts (shared completed-turn
 // semantics); re-exported here so existing imports keep working.
 export { turnEndedBadly } from "./cadence.js";
-
 // The auto-refine cadence counter (shared implementation — see cadence.ts).
 const cadence = makeTurnCadence();
-
 /** Test hook: reset internal counter. */
-export function resetAutoRefine(): void {
-  cadence.reset();
+export function resetAutoRefine() {
+    cadence.reset();
 }
-
 /**
  * Decide whether to auto-refine this turn. Side-effectful: the first observed
  * completed turn seeds the baseline (no refine then); every completed turn
@@ -62,39 +56,18 @@ export function resetAutoRefine(): void {
  * the cadence counts completed turns of work, never raw turn indices, so an
  * aborted turn in between cannot shorten the window.
  */
-export function evaluateAutoRefine(config: HarnessConfig, outcome?: string): boolean {
-  if (!config.autoRefine?.enabled) return false;
-  const every = config.autoRefine.everyTurns ?? DEFAULT_AUTO_EVERY_TURNS;
-  return cadence.tick(every, outcome);
+export function evaluateAutoRefine(config, outcome) {
+    if (!config.autoRefine?.enabled)
+        return false;
+    const every = config.autoRefine.everyTurns ?? DEFAULT_AUTO_EVERY_TURNS;
+    return cadence.tick(every, outcome);
 }
-
 /** The boundary draft custom type for auto-refine steering messages. */
 export const AUTO_REFINE_ENTRY = "harness.auto-refine-request";
-
 /** Build the boundary draft carrying a steering message. Pure — testable. */
-export function buildRefineDraft(steeringMessage: string): {
-  type: "custom_message";
-  customType: string;
-  content: string;
-  display: boolean;
-} {
-  return { type: "custom_message", customType: AUTO_REFINE_ENTRY, content: steeringMessage, display: true };
+export function buildRefineDraft(steeringMessage) {
+    return { type: "custom_message", customType: AUTO_REFINE_ENTRY, content: steeringMessage, display: true };
 }
-
-/** Structural slice of pi's ProjectedSessionEntry (sourceEntry + messages). */
-export interface ProjectedLike {
-  sourceEntry?: { type?: string; customType?: string; id?: string };
-  messages?: unknown[];
-}
-
-/** A context_edit boundary draft (pi ≥ 0.87): omit one entry from future
- *  provider context — raw history, usage, and UI history stay untouched. */
-export interface OmissionDraft {
-  type: "context_edit";
-  targetId: string;
-  replacement: null;
-}
-
 /**
  * Context-edit drafts omitting every LIVE prior auto-refine request from
  * future provider context (pi ≥ 0.87 ContextEditEntry). Invariant: at most
@@ -103,76 +76,76 @@ export interface OmissionDraft {
  * the operation is idempotent and never stacks redundant edits. Raw history
  * (and the HTML export) keeps every draft: /tree rollback still applies.
  */
-export function buildOmissionDrafts(projected: Iterable<ProjectedLike>): OmissionDraft[] {
-  const drafts: OmissionDraft[] = [];
-  for (const p of projected) {
-    const src = p.sourceEntry;
-    if (src?.type !== "custom_message" || src.customType !== AUTO_REFINE_ENTRY) continue;
-    if ((p.messages?.length ?? 0) === 0) continue; // already omitted → skip
-    if (typeof src.id === "string") drafts.push({ type: "context_edit", targetId: src.id, replacement: null });
-  }
-  return drafts;
+export function buildOmissionDrafts(projected) {
+    const drafts = [];
+    for (const p of projected) {
+        const src = p.sourceEntry;
+        if (src?.type !== "custom_message" || src.customType !== AUTO_REFINE_ENTRY)
+            continue;
+        if ((p.messages?.length ?? 0) === 0)
+            continue; // already omitted → skip
+        if (typeof src.id === "string")
+            drafts.push({ type: "context_edit", targetId: src.id, replacement: null });
+    }
+    return drafts;
 }
-
-/** Subscribe to turn_end and run /refine on the configured cadence. */
-export function registerAutoRefine(pi: ExtensionAPI): void {
-  pi.on("turn_end", async (event, ctx) => {
+/** turn_end handler — run /refine on the configured cadence. Returns the
+ *  boundary continuation when a steering draft lands (pi ≥ 0.87). Exported
+ *  so the thin entry (entry.ts) can delegate via dynamic import (issue #36). */
+export async function handleAutoRefineTurnEnd(pi, event, ctx) {
     const config = await loadConfig();
-    if (!evaluateAutoRefine(config, event.outcome)) return;
+    if (!evaluateAutoRefine(config, event.outcome))
+        return;
     const every = config.autoRefine?.everyTurns ?? DEFAULT_AUTO_EVERY_TURNS;
-
     // Opt-in classifier gate: cheap yes/no before spending the refine.
     if (config.autoRefine?.gate) {
-      const classify = buildClassify(ctx, config.classifier?.model);
-      if (classify) {
-        const evidence = gatherEvidence(ctx, DEFAULT_LOOKBACK_TURNS);
-        const res = await classify(buildGateRequest(evidence));
-        const decision = gateDecision(res);
-        if (!decision.proceed) {
-          ctx.ui.notify(`Auto-refine: skipped — ${decision.because}.`, "info");
-          return;
+        const classify = buildClassify(ctx, config.classifier?.model);
+        if (classify) {
+            const evidence = gatherEvidence(ctx, DEFAULT_LOOKBACK_TURNS);
+            const res = await classify(buildGateRequest(evidence));
+            const decision = gateDecision(res);
+            if (!decision.proceed) {
+                ctx.ui.notify(`Auto-refine: skipped — ${decision.because}.`, "info");
+                return;
+            }
+            ctx.ui.notify(`Auto-refine: gate passed (${decision.because}).`, "info");
         }
-        ctx.ui.notify(`Auto-refine: gate passed (${decision.because}).`, "info");
-      }
-      // No resolvable classifier → plain cadence behavior (documented soft-fail).
+        // No resolvable classifier → plain cadence behavior (documented soft-fail).
     }
-
     ctx.ui.notify(`Auto-refine: running /refine (every ${every} turns, opt-in).`, "info");
     try {
-      const result = await runRefine(
-        pi,
-        ctx,
-        {
-          commit: config.autoRefine?.commit ?? false,
-          ...(config.proposer ? { proposer: config.proposer } : {}),
-          delivery: "boundary",
-        },
-        "auto",
-      );
-      // Boundary delivery: persist the steering message as a structural entry
-      // and guarantee one next provider request. Only when the boundary CAN
-      // continue — otherwise fall back to the legacy steering send.
-      if (result.steeringMessage) {
-        if (event.context?.canContinue === false) {
-          pi.sendUserMessage(result.steeringMessage);
-          return;
+        const result = await runRefine(pi, ctx, {
+            commit: config.autoRefine?.commit ?? false,
+            ...(config.proposer ? { proposer: config.proposer } : {}),
+            delivery: "boundary",
+        }, "auto");
+        // Boundary delivery: persist the steering message as a structural entry
+        // and guarantee one next provider request. Only when the boundary CAN
+        // continue — otherwise fall back to the legacy steering send.
+        if (result.steeringMessage) {
+            if (event.context?.canContinue === false) {
+                pi.sendUserMessage(result.steeringMessage);
+                return;
+            }
+            // Hygiene (pi ≥ 0.87 context edits): omit every LIVE prior auto-refine
+            // request from future provider context, so at most one draft (the new
+            // one) is ever model-visible. Already-omitted drafts are skipped by
+            // buildOmissionDrafts; raw history and /tree rollback are untouched.
+            // Kill-switch: autoRefine.omitStaleDrafts: false.
+            const omissions = config.autoRefine?.omitStaleDrafts === false
+                ? []
+                : buildOmissionDrafts(event.context?.contextEntries ?? []);
+            return {
+                entries: [...event.entries, ...omissions, buildRefineDraft(result.steeringMessage)],
+                continue: true,
+            };
         }
-        // Hygiene (pi ≥ 0.87 context edits): omit every LIVE prior auto-refine
-        // request from future provider context, so at most one draft (the new
-        // one) is ever model-visible. Already-omitted drafts are skipped by
-        // buildOmissionDrafts; raw history and /tree rollback are untouched.
-        // Kill-switch: autoRefine.omitStaleDrafts: false.
-        const omissions =
-          config.autoRefine?.omitStaleDrafts === false
-            ? []
-            : buildOmissionDrafts(event.context?.contextEntries ?? []);
-        return {
-          entries: [...event.entries, ...omissions, buildRefineDraft(result.steeringMessage)],
-          continue: true,
-        };
-      }
-    } catch (err) {
-      ctx.ui.notify(`Auto-refine failed: ${(err as Error).message}`, "error");
     }
-  });
+    catch (err) {
+        ctx.ui.notify(`Auto-refine failed: ${err.message}`, "error");
+    }
+}
+/** Subscribe to turn_end and run /refine on the configured cadence. */
+export function registerAutoRefine(pi) {
+    pi.on("turn_end", (event, ctx) => handleAutoRefineTurnEnd(pi, event, ctx));
 }

package/dist/cadence.d.ts

@@ -0,0 +1,14 @@
+/** True when a turn_end's outcome marks a turn that ended badly (pi's
+ *  BoundaryState.outcome: "aborted" | "error"). Undefined is treated as
+ *  completed — current pi always reports the field, but synthetic events and
+ *  the earliest 0.99.x may omit it. */
+export declare function turnEndedBadly(outcome?: string): boolean;
+export interface TurnCadence {
+    /** Observe a turn boundary; true when the cadence fires this turn.
+     *  Aborted/error outcomes and every <= 0 are inert (state untouched). */
+    tick(every: number, outcome?: string): boolean;
+    /** Back to the unseen baseline (session_start: a fork/resume opens a fresh window). */
+    reset(): void;
+}
+/** One independent cadence counter. Feature gates stay with the caller. */
+export declare function makeTurnCadence(): TurnCadence;

package/{src/cadence.ts → dist/cadence.js}

@@ -12,45 +12,37 @@
 //  - The seed turn itself does not count.
 //  - every <= 0 disables the cadence (tick never fires).
 //  - Firing resets the count, so the firing turn itself never re-triggers.
-
 /** True when a turn_end's outcome marks a turn that ended badly (pi's
  *  BoundaryState.outcome: "aborted" | "error"). Undefined is treated as
  *  completed — current pi always reports the field, but synthetic events and
  *  the earliest 0.99.x may omit it. */
-export function turnEndedBadly(outcome?: string): boolean {
-  return outcome === "aborted" || outcome === "error";
+export function turnEndedBadly(outcome) {
+    return outcome === "aborted" || outcome === "error";
 }
-
-export interface TurnCadence {
-  /** Observe a turn boundary; true when the cadence fires this turn.
-   *  Aborted/error outcomes and every <= 0 are inert (state untouched). */
-  tick(every: number, outcome?: string): boolean;
-  /** Back to the unseen baseline (session_start: a fork/resume opens a fresh window). */
-  reset(): void;
-}
-
 /** One independent cadence counter. Feature gates stay with the caller. */
-export function makeTurnCadence(): TurnCadence {
-  // Completed turns observed since the last fire (or the seeded baseline).
-  // -1 = unseen.
-  let completedTurns = -1;
-  return {
-    tick(every, outcome) {
-      if (turnEndedBadly(outcome)) return false;
-      if (every <= 0) return false;
-      if (completedTurns < 0) {
-        completedTurns = 0; // seed: the seed turn itself doesn't count
-        return false;
-      }
-      completedTurns += 1;
-      if (completedTurns >= every) {
-        completedTurns = 0;
-        return true;
-      }
-      return false;
-    },
-    reset() {
-      completedTurns = -1;
-    },
-  };
+export function makeTurnCadence() {
+    // Completed turns observed since the last fire (or the seeded baseline).
+    // -1 = unseen.
+    let completedTurns = -1;
+    return {
+        tick(every, outcome) {
+            if (turnEndedBadly(outcome))
+                return false;
+            if (every <= 0)
+                return false;
+            if (completedTurns < 0) {
+                completedTurns = 0; // seed: the seed turn itself doesn't count
+                return false;
+            }
+            completedTurns += 1;
+            if (completedTurns >= every) {
+                completedTurns = 0;
+                return true;
+            }
+            return false;
+        },
+        reset() {
+            completedTurns = -1;
+        },
+    };
 }

package/dist/classify.d.ts

@@ -0,0 +1,94 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+/** One yes/no question in a ClassifyFn request. */
+export interface ClassifyBoolQuestion {
+    instructions: string;
+    /** Criteria text for the yes answer. */
+    trueCriteria: string;
+    /** Criteria text for the no answer. */
+    falseCriteria: string;
+}
+/** A parsed answer per question key. */
+export interface ClassifyBoolAnswer {
+    /** The classifier's decision. */
+    value: boolean;
+    /** [0,1] confidence when the engine reports one. */
+    confidence?: number;
+}
+/** Result of a ClassifyFn call: one answer per question key, or an error. */
+export interface ClassifyBoolResult {
+    ok: boolean;
+    answers: Record<string, ClassifyBoolAnswer>;
+    /** Resolved classifier label ("provider/id") for telemetry. */
+    model?: string;
+    /** Token usage when the engine reports it (for the audit trail). */
+    usage?: {
+        input: number;
+        output: number;
+    };
+    error?: string;
+}
+/**
+ * Batched yes/no classification seam injected into ProposeInput when a
+ * classifier model is configured AND resolvable. Structural on purpose —
+ * the adapter below is the only place that knows pi-ai's shapes.
+ */
+export type ClassifyFn = (input: {
+    state: Record<string, unknown>;
+    questions: Record<string, ClassifyBoolQuestion>;
+}) => Promise<ClassifyBoolResult>;
+/** Structural slice of ctx.modelRegistry used here. */
+interface RegistryLike {
+    classify?: (model: unknown, context: unknown, options?: unknown) => Promise<ClassifyRawResult>;
+    findOfType?: (type: "classifier", provider: string, id: string) => unknown | undefined;
+    getModelsOfType?: (type: "classifier") => readonly unknown[];
+}
+/** Raw pi-ai ClassifierResult slice (never rejects, but stopReason may be error). */
+interface ClassifyRawResult {
+    answers?: Record<string, {
+        type?: string;
+        choice?: unknown;
+        score?: number;
+        probability?: number;
+        confidence?: number;
+    }>;
+    stopReason?: string;
+    errorMessage?: string;
+}
+/** Raw classifier-model slice (Model<ClassifierApi>). */
+interface ClassifierModelLike {
+    provider?: string;
+    id?: string;
+}
+/**
+ * Resolve a classifier model from a configured id ("provider/id" or bare id).
+ * Returns undefined when unconfigured or unresolvable — every feature keyed on
+ * it then degrades to its no-classifier behavior.
+ */
+export declare function resolveClassifierModel(registry: RegistryLike | undefined, configured?: string): ClassifierModelLike | undefined;
+/** Build the ClassifyFn adapter over a resolved classifier model. */
+export declare function makeClassifyFn(registry: RegistryLike, model: ClassifierModelLike, signal?: AbortSignal): ClassifyFn;
+/**
+ * Resolve the ClassifyFn for a session from config + ctx, or undefined.
+ * The single construction point shared by refine (ProposeInput.classify) and
+ * the auto-refine gate.
+ */
+export declare function buildClassify(ctx: ExtensionContext, configuredModel?: string): ClassifyFn | undefined;
+/**
+ * The auto-refine gate question: did the recent trajectory contain a durable,
+ * reusable correction worth a /refine pass? Pure builder — unit-testable.
+ * Keeps the state payload bounded (the caller already bounds evidence bytes).
+ */
+export declare function buildGateRequest(evidence: string): {
+    state: Record<string, unknown>;
+    questions: Record<string, ClassifyBoolQuestion>;
+};
+/**
+ * Gate decision from a classify result. Errors and missing answers fall back to
+ * `true` (proceed) so a flaky classifier never disables refinement — the gate
+ * can only SKIP work, never block it.
+ */
+export declare function gateDecision(result: ClassifyBoolResult): {
+    proceed: boolean;
+    because: string;
+};
+export {};

package/dist/classify.js

@@ -0,0 +1,145 @@
+// Classifier adapter (pi ≥ 0.99). Wraps ctx.modelRegistry.classify() — cheap
+// typed yes/no or score questions answered from next-token label probabilities
+// (local llama.cpp) or a hosted Jev model — behind two package seams:
+//
+//  1. autoRefine gate (auto-refine.ts): when the cadence elapses, ask ONE bool
+//     question over the recent trajectory ("did it contain a durable, reusable
+//     correction?") and skip the refine when the answer is no. Soft-fails to the
+//     old cadence behavior on any classifier error, so a flaky classifier never
+//     blocks refinement.
+//  2. dedupe confirmation (proposer.ts): a precision filter on candidate merge
+//     pairs — see classifyConfirmPairs().
+//
+// The pi-ai classifier shapes (ClassifierContext/ClassifierQuestion/…) are kept
+// OUT of the public proposer interface: ClassifyFn below is a minimal structural
+// contract so proposers stay testable without pi runtime types.
+/**
+ * Resolve a classifier model from a configured id ("provider/id" or bare id).
+ * Returns undefined when unconfigured or unresolvable — every feature keyed on
+ * it then degrades to its no-classifier behavior.
+ */
+export function resolveClassifierModel(registry, configured) {
+    if (!configured || !registry)
+        return undefined;
+    const slash = configured.indexOf("/");
+    if (slash > 0 && typeof registry.findOfType === "function") {
+        const byPair = registry.findOfType("classifier", configured.slice(0, slash), configured.slice(slash + 1));
+        if (byPair)
+            return byPair;
+    }
+    const all = typeof registry.getModelsOfType === "function"
+        ? [...registry.getModelsOfType("classifier")]
+        : [];
+    return (all.find((m) => {
+        const cm = m;
+        return cm.id === configured || `${cm.provider}/${cm.id}` === configured;
+    }) ?? undefined);
+}
+/** Build the ClassifyFn adapter over a resolved classifier model. */
+export function makeClassifyFn(registry, model, signal) {
+    const label = `${model.provider}/${model.id}`;
+    return async ({ state, questions }) => {
+        if (typeof registry.classify !== "function") {
+            return { ok: false, answers: {}, model: label, error: "modelRegistry.classify unavailable" };
+        }
+        // Map our minimal bool contract onto pi-ai's ClassifierBoolQuestion.
+        const piQuestions = {};
+        for (const [key, q] of Object.entries(questions)) {
+            piQuestions[key] = {
+                type: "bool",
+                instructions: q.instructions,
+                criteria: { true: q.trueCriteria, false: q.falseCriteria },
+            };
+        }
+        let raw;
+        try {
+            raw = (await registry.classify(model, { state, questions: piQuestions }, signal ? { signal } : undefined));
+        }
+        catch (err) {
+            // classify "never rejects", but stay defensive around transport edges.
+            return { ok: false, answers: {}, model: label, error: err.message };
+        }
+        const usage = typeof raw.usage?.input === "number" &&
+            typeof raw.usage?.output === "number"
+            ? {
+                input: raw.usage.input,
+                output: raw.usage.output,
+            }
+            : undefined;
+        if (raw.stopReason && raw.stopReason !== "stop") {
+            return {
+                ok: false,
+                answers: {},
+                model: label,
+                ...(usage ? { usage } : {}),
+                error: raw.errorMessage ?? `stopReason ${raw.stopReason}`,
+            };
+        }
+        const answers = {};
+        for (const [key, a] of Object.entries(raw.answers ?? {})) {
+            let value;
+            let confidence;
+            if (a?.type === "bool") {
+                // Bool answers carry the probability of TRUE.
+                value = (a.probability ?? 0) >= 0.5;
+                confidence = a.probability;
+            }
+            else if (a?.type === "choice") {
+                value = a.choice === true || a.choice === "true";
+                confidence = a.confidence;
+            }
+            else if (a?.type === "score") {
+                value = (a.score ?? 0) >= 0.5;
+                confidence = a.confidence;
+            }
+            if (value !== undefined) {
+                answers[key] = { value, ...(typeof confidence === "number" ? { confidence } : {}) };
+            }
+        }
+        return { ok: true, answers, model: label, ...(usage ? { usage } : {}) };
+    };
+}
+/**
+ * Resolve the ClassifyFn for a session from config + ctx, or undefined.
+ * The single construction point shared by refine (ProposeInput.classify) and
+ * the auto-refine gate.
+ */
+export function buildClassify(ctx, configuredModel) {
+    const registry = ctx.modelRegistry;
+    const model = resolveClassifierModel(registry, configuredModel);
+    if (!registry || !model)
+        return undefined;
+    return makeClassifyFn(registry, model, ctx.signal);
+}
+/**
+ * The auto-refine gate question: did the recent trajectory contain a durable,
+ * reusable correction worth a /refine pass? Pure builder — unit-testable.
+ * Keeps the state payload bounded (the caller already bounds evidence bytes).
+ */
+export function buildGateRequest(evidence) {
+    return {
+        state: { trajectory: evidence },
+        questions: {
+            gate: {
+                instructions: "You are gating an online self-improvement pass for a coding agent. Does the recent trajectory below contain a durable, reusable correction — a mistake fixed, a preference learned, a convention discovered, or a fact worth remembering across sessions — that is NOT already routine work?",
+                trueCriteria: "The trajectory contains at least one durable, reusable lesson or correction worth persisting into the agent's harness state.",
+                falseCriteria: "The trajectory is routine work (ordinary edits, reads, test runs) with no reusable correction worth persisting.",
+            },
+        },
+    };
+}
+/**
+ * Gate decision from a classify result. Errors and missing answers fall back to
+ * `true` (proceed) so a flaky classifier never disables refinement — the gate
+ * can only SKIP work, never block it.
+ */
+export function gateDecision(result) {
+    if (!result.ok)
+        return { proceed: true, because: `classifier error (${result.error ?? "unknown"}); falling back to cadence` };
+    const a = result.answers.gate;
+    if (!a)
+        return { proceed: true, because: "no gate answer; falling back to cadence" };
+    return a.value
+        ? { proceed: true, because: `classifier: yes (confidence ${a.confidence ?? "?"})` }
+        : { proceed: false, because: `classifier: no durable correction (confidence ${a.confidence ?? "?"})` };
+}

package/dist/command-meta.d.ts

@@ -0,0 +1,2 @@
+export declare const REFINE_COMMAND_DESCRIPTION = "Online self-improvement: review recent trajectory and propose evidence-backed CRUD deltas to the harness state. Usage: /refine [lookback-turns] [--commit] [--proposer steering|dedupe] [--threshold 0.75]";
+export declare const HARNESS_COMMAND_DESCRIPTION: string;

package/dist/command-meta.js

@@ -0,0 +1,9 @@
+// Command registration metadata shared by the thin entry (entry.ts) and the
+// feature modules' own register functions (refine.ts, harness.ts). Registration
+// must be synchronous at factory time, so the description strings cannot live
+// behind a dynamic import — but they CAN live in this tiny data module both
+// paths share, which keeps them from drifting apart (issue #36).
+export const REFINE_COMMAND_DESCRIPTION = "Online self-improvement: review recent trajectory and propose evidence-backed CRUD deltas to the harness state. Usage: /refine [lookback-turns] [--commit] [--proposer steering|dedupe] [--threshold 0.75]";
+export const HARNESS_COMMAND_DESCRIPTION = "Durable harness-state I/O + importance hygiene " +
+    "(import · export · status · adopt · prune · keep · drop · push-mem — " +
+    "subcommands autocomplete as you type)";