muonroi-cli 1.3.4 → 1.4.1

package/src/ee/phase-outcome.ts

@@ -1,165 +0,0 @@
-/**
- * src/ee/phase-outcome.ts
- *
- * P1 Item 3 client wrapper for the EE /api/phase-outcome endpoint.
- *
- * Translates a GSD phase boundary into a phase-grain reinforcement call so
- * the brain can credit-assign all principles that fired during the phase
- * with a single high-SNR verdict (verifier pass/fail/abandoned) instead of
- * relying on per-tool noise.
- *
- * The endpoint is gated behind `ENABLE_PHASE_OUTCOME=1` on the server. When
- * the server returns 404 or any error, this client logs once and continues
- * — phase outcome is best-effort reinforcement, never a blocker.
- *
- * Honors B-4: never blocks the agent. Posts are fire-and-forget unless the
- * caller explicitly awaits the returned Promise.
- */
-
-import { classifyEeError, logEeFailure } from "../utils/ee-logger.js";
-import type { CouncilJudgeResult } from "./judge.js";
-import type { Scope } from "./types.js";
-
-export type PhaseOutcomeKind = "pass" | "fail" | "abandoned" | "aborted" | "resumed";
-
-export interface PrincipleRef {
-  collection: string;
-  pointId: string;
-}
-
-export interface PhaseOutcomePayload {
-  sessionId: string;
-  phaseName: string;
-  outcome: PhaseOutcomeKind;
-  evidence?: {
-    verifierResult?: { passed: number; failed: number };
-    durationMs?: number;
-    toolCount?: number;
-    cwd?: string;
-    [k: string]: unknown;
-  };
-  /**
-   * Principles that fired during the phase. The orchestrator collects these
-   * from intercept responses and from session trajectory matchIds.
-   */
-  toolEventIds?: PrincipleRef[];
-  /** Optional scope passthrough — currently unused server-side but reserved. */
-  scope?: Scope;
-}
-
-export interface PhaseOutcomeResult {
-  ok: boolean;
-  applied?: number;
-  skipped?: number;
-  cached?: boolean;
-  error?: string;
-}
-
-const DEFAULT_BASE = "http://localhost:8082";
-const DEFAULT_TIMEOUT_MS = 3000;
-
-let _warnedOnce = false;
-
-export interface FirePhaseOutcomeOpts {
-  baseUrl?: string;
-  authToken?: string;
-  timeoutMs?: number;
-  fetchImpl?: typeof fetch;
-}
-
-/**
- * Fire a phase outcome to the EE server.
- *
- * Returns the parsed result on success, or `null` when the call fails for
- * any reason (server unreachable, 404, timeout). All errors are swallowed
- * after a single warning per process.
- */
-export async function firePhaseOutcome(
-  payload: PhaseOutcomePayload,
-  opts: FirePhaseOutcomeOpts = {},
-): Promise<PhaseOutcomeResult | null> {
-  const baseUrl = opts.baseUrl ?? DEFAULT_BASE;
-  const f = opts.fetchImpl ?? fetch;
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const headers: Record<string, string> = { "Content-Type": "application/json" };
-  if (opts.authToken) headers.Authorization = `Bearer ${opts.authToken}`;
-
-  try {
-    const resp = await f(`${baseUrl}/api/phase-outcome`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(payload),
-      signal: AbortSignal.timeout(timeoutMs),
-    });
-    if (!resp.ok) {
-      // 404 = endpoint disabled (feature flag off); silently ignore.
-      if (resp.status !== 404 && !_warnedOnce) {
-        _warnedOnce = true;
-        // eslint-disable-next-line no-console
-        console.warn(`[ee] phase-outcome non-OK ${resp.status} (silenced after first warning)`);
-      }
-      return null;
-    }
-    const json = (await resp.json()) as PhaseOutcomeResult;
-    return json;
-  } catch (err) {
-    if (!_warnedOnce) {
-      _warnedOnce = true;
-      // eslint-disable-next-line no-console
-      console.warn(`[ee] phase-outcome failed: ${(err as Error).message} (silenced after first warning)`);
-    }
-    return null;
-  }
-}
-
-/** Fire-and-forget wrapper that never throws. */
-export function fireAndForgetPhaseOutcome(payload: PhaseOutcomePayload, opts: FirePhaseOutcomeOpts = {}): void {
-  void firePhaseOutcome(payload, opts).catch((err) => {
-    logEeFailure("phase-outcome.fireAndForgetPhaseOutcome", classifyEeError(err), err);
-    /* swallow */
-  });
-}
-
-/** Test-only: reset the once-per-process warning latch. */
-export function _resetPhaseOutcomeState(): void {
-  _warnedOnce = false;
-}
-
-export interface RecordCouncilOutcomeOpts {
-  sessionId?: string;
-  durationMs?: number;
-  baseUrl?: string;
-  authToken?: string;
-}
-
-/**
- * Fire-and-forget council outcome to EE brain.
- * Maps verdict → PhaseOutcomeKind: pass/fail/abandoned.
- * B-4 compliant — never blocks. Never throws.
- */
-export function recordCouncilOutcome(
-  topic: string,
-  synthesis: string,
-  verdict: CouncilJudgeResult,
-  opts: RecordCouncilOutcomeOpts = {},
-): void {
-  const outcomeKind: PhaseOutcomeKind =
-    verdict.verdict === "pass" ? "pass" : verdict.verdict === "needs_review" ? "fail" : "abandoned";
-
-  const payload: PhaseOutcomePayload = {
-    sessionId: opts.sessionId ?? "council",
-    phaseName: `council:${topic.slice(0, 60)}`,
-    outcome: outcomeKind,
-    evidence: {
-      synthesisLength: synthesis.length,
-      confidence: verdict.confidence,
-      judgeReason: verdict.reason,
-      durationMs: opts.durationMs,
-    },
-  };
-
-  void firePhaseOutcome(payload, { baseUrl: opts.baseUrl, authToken: opts.authToken }).catch((err) => {
-    logEeFailure("phase-outcome.recordCouncilOutcome", classifyEeError(err), err);
-    /* swallow — non-critical */
-  });
-}

package/src/ee/phase-tracker.test.ts

@@ -1,175 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import {
-  _peekState,
-  classifyOutcome,
-  endPhase,
-  markAborted,
-  type PhaseSnapshot,
-  recordIntercept,
-  recordPostTool,
-  resetPhaseTracker,
-  setPhase,
-} from "./phase-tracker.js";
-
-const refA = { collection: "code", pointId: "a" };
-const refB = { collection: "code", pointId: "b" };
-
-beforeEach(() => resetPhaseTracker());
-afterEach(() => resetPhaseTracker());
-
-describe("setPhase boundary semantics", () => {
-  it("returns null when starting from no active phase", () => {
-    expect(setPhase("implement")).toBeNull();
-    expect(_peekState()?.phaseName).toBe("implement");
-  });
-
-  it("returns null when called with the same phase", () => {
-    setPhase("implement");
-    expect(setPhase("implement")).toBeNull();
-  });
-
-  it("returns a snapshot when the phase name changes", () => {
-    setPhase("implement");
-    recordIntercept([refA]);
-    recordPostTool({ success: true, verifyResult: "pass" });
-    const snap = setPhase("verify");
-    expect(snap).not.toBeNull();
-    expect(snap!.phaseName).toBe("implement");
-    expect(snap!.principleRefs).toEqual([refA]);
-    expect(snap!.verifyResult).toBe("pass");
-    expect(_peekState()?.phaseName).toBe("verify");
-  });
-
-  it("setPhase(null) ends the phase and returns a snapshot", () => {
-    setPhase("implement");
-    recordIntercept([refA]);
-    const snap = setPhase(null);
-    expect(snap?.phaseName).toBe("implement");
-    expect(_peekState()).toBeNull();
-  });
-});
-
-describe("recordIntercept", () => {
-  it("dedupes principle IDs across multiple intercepts in the same phase", () => {
-    setPhase("implement");
-    recordIntercept([refA]);
-    recordIntercept([refA, refB]);
-    const snap = endPhase();
-    expect(snap!.principleRefs.map((r) => r.pointId).sort()).toEqual(["a", "b"]);
-    expect(snap!.toolCount).toBe(2); // tool count increments per call
-  });
-
-  it("is a no-op when no phase is active", () => {
-    recordIntercept([refA]);
-    expect(_peekState()).toBeNull();
-  });
-
-  it("filters out malformed refs", () => {
-    setPhase("implement");
-    recordIntercept([
-      refA,
-      { collection: "", pointId: "no-coll" } as { collection: string; pointId: string },
-      // @ts-expect-error null entry
-      null,
-    ]);
-    const snap = endPhase();
-    expect(snap!.principleRefs).toEqual([refA]);
-  });
-});
-
-describe("recordPostTool", () => {
-  it("flags hadFailure on success=false", () => {
-    setPhase("implement");
-    recordPostTool({ success: false });
-    const snap = endPhase();
-    expect(snap!.hadFailure).toBe(true);
-    expect(snap!.verifyResult).toBeNull();
-  });
-
-  it("captures verifyResult", () => {
-    setPhase("verify");
-    recordPostTool({ success: true, verifyResult: "fail" });
-    const snap = endPhase();
-    expect(snap!.verifyResult).toBe("fail");
-  });
-});
-
-describe("markAborted", () => {
-  it("sets aborted flag with reason", () => {
-    setPhase("implement");
-    markAborted("user-pressed-esc");
-    const snap = endPhase();
-    expect(snap!.aborted).toBe(true);
-    expect(snap!.abortReason).toBe("user-pressed-esc");
-  });
-
-  it("is a no-op when no phase active", () => {
-    markAborted("x");
-    expect(_peekState()).toBeNull();
-  });
-});
-
-describe("classifyOutcome", () => {
-  function snap(over: Partial<PhaseSnapshot>): PhaseSnapshot {
-    return {
-      phaseName: "implement",
-      startedAt: 0,
-      endedAt: 1,
-      toolCount: 0,
-      principleRefs: [],
-      verifyResult: null,
-      hadFailure: false,
-      aborted: false,
-      ...over,
-    };
-  }
-
-  it("aborted → abandoned", () => {
-    expect(classifyOutcome(snap({ aborted: true, verifyResult: "pass" }))).toBe("abandoned");
-  });
-
-  it("verifyResult=fail → fail", () => {
-    expect(classifyOutcome(snap({ verifyResult: "fail" }))).toBe("fail");
-  });
-
-  it("verifyResult=pass → pass", () => {
-    expect(classifyOutcome(snap({ verifyResult: "pass" }))).toBe("pass");
-  });
-
-  it("hadFailure alone returns null (insufficient signal)", () => {
-    expect(classifyOutcome(snap({ hadFailure: true }))).toBeNull();
-  });
-
-  it("nothing observed returns null", () => {
-    expect(classifyOutcome(snap({}))).toBeNull();
-  });
-});
-
-describe("end-to-end phase lifecycle", () => {
-  it("captures verify-pass workflow", () => {
-    // Turn 1: implement
-    setPhase("implement");
-    recordIntercept([refA, refB]);
-    recordPostTool({ success: true });
-
-    // Turn 2: verify (boundary)
-    const drained = setPhase("verify");
-    expect(drained!.phaseName).toBe("implement");
-    expect(classifyOutcome(drained!)).toBeNull(); // no verify outcome yet
-
-    recordPostTool({ success: true, verifyResult: "pass" });
-
-    // Turn 3: review (boundary again)
-    const drained2 = setPhase("review");
-    expect(drained2!.phaseName).toBe("verify");
-    expect(classifyOutcome(drained2!)).toBe("pass");
-  });
-
-  it("captures abort mid-phase as abandoned", () => {
-    setPhase("execute");
-    recordIntercept([refA]);
-    markAborted("user-pressed-esc");
-    const drained = endPhase();
-    expect(classifyOutcome(drained!)).toBe("abandoned");
-  });
-});

package/src/ee/phase-tracker.ts

@@ -1,180 +0,0 @@
-/**
- * src/ee/phase-tracker.ts
- *
- * P1 Item 3 wiring: in-memory phase tracker.
- *
- * Aggregates the runtime signals (principles fired, verifier outcomes, abort
- * events) for the *current* GSD phase. The orchestrator calls `setPhase()`
- * at every user-turn boundary; when the phase changes from a non-null prior
- * phase, the tracker drains a snapshot the orchestrator forwards to
- * `firePhaseOutcome`.
- *
- * Why a singleton: the hook layer surfaces principle IDs at PreToolUse and
- * verify outcomes at PostToolUse. The orchestrator only sees turn boundaries.
- * A module-level tracker bridges the two without weaving a context object
- * through every hook call site (mirrors the `_lastWarningResponse` /
- * `MistakeDetector` pattern already in place).
- *
- * Honors B-4: never throws. Tracker corruption (e.g., somehow a record gets
- * miswired) cannot block the agent.
- */
-
-import type { PhaseOutcomeKind, PrincipleRef } from "./phase-outcome.js";
-
-export interface PhaseSnapshot {
-  phaseName: string;
-  startedAt: number;
-  endedAt: number;
-  toolCount: number;
-  principleRefs: PrincipleRef[];
-  /** Aggregate verifier verdict observed during the phase. */
-  verifyResult: "pass" | "fail" | "skip" | null;
-  hadFailure: boolean;
-  aborted: boolean;
-  abortReason?: string;
-}
-
-interface PhaseState {
-  phaseName: string;
-  startedAt: number;
-  toolCount: number;
-  principleRefs: PrincipleRef[];
-  /** Track unique principle IDs to avoid double-counting on repeat surfaces. */
-  seenPrincipleIds: Set<string>;
-  verifyResult: "pass" | "fail" | "skip" | null;
-  hadFailure: boolean;
-  aborted: boolean;
-  abortReason?: string;
-}
-
-let _state: PhaseState | null = null;
-
-function newState(phaseName: string): PhaseState {
-  return {
-    phaseName,
-    startedAt: Date.now(),
-    toolCount: 0,
-    principleRefs: [],
-    seenPrincipleIds: new Set(),
-    verifyResult: null,
-    hadFailure: false,
-    aborted: false,
-  };
-}
-
-/**
- * Determine the phase outcome from collected signals.
- *
- * Conservative — only returns a verdict when we have an unambiguous signal:
- *   - aborted        → "abandoned"
- *   - verifyResult=fail → "fail"
- *   - verifyResult=pass → "pass"
- *   - everything else  → null (don't fire — insufficient signal)
- *
- * `hadFailure` alone does NOT fire a verdict: tool failures during execute
- * happen even on successful phases (build retries, recoverable errors).
- * Only the explicit verifier verdict is high-SNR enough.
- */
-export function classifyOutcome(snap: PhaseSnapshot): PhaseOutcomeKind | null {
-  if (snap.aborted) return "abandoned";
-  if (snap.verifyResult === "fail") return "fail";
-  if (snap.verifyResult === "pass") return "pass";
-  return null;
-}
-
-/**
- * Record principle refs surfaced by an intercept call. Dedupes by
- * principle_uuid so a re-surface in a later tool of the same phase doesn't
- * inflate the credit-assignment list.
- */
-export function recordIntercept(refs: PrincipleRef[]): void {
-  if (!_state) return;
-  if (!Array.isArray(refs) || refs.length === 0) return;
-  _state.toolCount++;
-  for (const ref of refs) {
-    if (!ref || !ref.pointId || !ref.collection) continue;
-    if (_state.seenPrincipleIds.has(ref.pointId)) continue;
-    _state.seenPrincipleIds.add(ref.pointId);
-    _state.principleRefs.push(ref);
-  }
-}
-
-/** Mark whether the latest posttool succeeded + carry verify outcome. */
-export function recordPostTool(opts: { success: boolean; verifyResult?: "pass" | "fail" | "skip" }): void {
-  if (!_state) return;
-  if (!opts.success) _state.hadFailure = true;
-  if (opts.verifyResult) {
-    // Last verifyResult wins, but a "fail" sticks unless explicitly overridden
-    // by a later "pass" (rare but possible if user re-runs verifier).
-    _state.verifyResult = opts.verifyResult;
-  }
-}
-
-/** Record abort event (called from the orchestrator's abort listener). */
-export function markAborted(reason?: string): void {
-  if (!_state) return;
-  _state.aborted = true;
-  if (reason) _state.abortReason = reason;
-}
-
-/**
- * Set the current phase. When the phase NAME changes from a non-null prior
- * phase, returns a snapshot of the prior phase for the orchestrator to ship.
- *
- * Calling with the same name is a no-op (continues accumulating).
- * Calling with `null` ends the current phase WITHOUT returning a snapshot —
- * use `endPhase()` for explicit termination.
- */
-export function setPhase(phaseName: string | null): PhaseSnapshot | null {
-  // Same phase as before → continue accumulating.
-  if (_state?.phaseName === phaseName) return null;
-
-  let drained: PhaseSnapshot | null = null;
-  if (_state) {
-    drained = {
-      phaseName: _state.phaseName,
-      startedAt: _state.startedAt,
-      endedAt: Date.now(),
-      toolCount: _state.toolCount,
-      principleRefs: [..._state.principleRefs],
-      verifyResult: _state.verifyResult,
-      hadFailure: _state.hadFailure,
-      aborted: _state.aborted,
-      ...(_state.abortReason ? { abortReason: _state.abortReason } : {}),
-    };
-  }
-
-  _state = phaseName ? newState(phaseName) : null;
-  return drained;
-}
-
-/**
- * Explicitly end the current phase. Returns the snapshot if any. Used at
- * session end to flush the last open phase.
- */
-export function endPhase(): PhaseSnapshot | null {
-  if (!_state) return null;
-  const drained: PhaseSnapshot = {
-    phaseName: _state.phaseName,
-    startedAt: _state.startedAt,
-    endedAt: Date.now(),
-    toolCount: _state.toolCount,
-    principleRefs: [..._state.principleRefs],
-    verifyResult: _state.verifyResult,
-    hadFailure: _state.hadFailure,
-    aborted: _state.aborted,
-    ...(_state.abortReason ? { abortReason: _state.abortReason } : {}),
-  };
-  _state = null;
-  return drained;
-}
-
-/** Test-only — reset all tracker state. */
-export function resetPhaseTracker(): void {
-  _state = null;
-}
-
-/** Test-only introspection — return the current state, or null if no phase active. */
-export function _peekState(): Readonly<PhaseState> | null {
-  return _state;
-}

package/src/ee/posttool.test.ts

@@ -1,81 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { JudgeContext } from "./judge.js";
-import type { PostToolPayload } from "./types.js";
-
-// Mock both intercept and judge modules
-// posttool is now async — mock must return a Promise so await works correctly
-const mockPosttool = vi.fn().mockResolvedValue(undefined);
-
-vi.mock("./intercept.js", () => ({
-  getDefaultEEClient: () => ({
-    posttool: mockPosttool,
-  }),
-}));
-
-vi.mock("./judge.js", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("./judge.js")>();
-  return {
-    ...actual,
-    fireFeedback: vi.fn(),
-  };
-});
-
-const mockPayload: PostToolPayload = {
-  toolName: "bash",
-  toolInput: { command: "ls" },
-  outcome: { success: true, exitCode: 0, durationMs: 10 },
-  cwd: "/tmp",
-  tenantId: "local",
-  scope: { kind: "global" },
-};
-
-describe("posttool() wrapper", () => {
-  it("calls client.posttool with payload", async () => {
-    mockPosttool.mockClear();
-    const { posttool } = await import("./posttool.js");
-    await posttool(mockPayload);
-    expect(mockPosttool).toHaveBeenCalledOnce();
-    expect(mockPosttool).toHaveBeenCalledWith(mockPayload);
-  });
-
-  it("calls fireFeedback when judgeCtx provided", async () => {
-    mockPosttool.mockClear();
-    const { posttool } = await import("./posttool.js");
-    const { fireFeedback } = await import("./judge.js");
-    const mockFF = fireFeedback as unknown as ReturnType<typeof vi.fn>;
-    mockFF.mockClear();
-
-    const ctx: JudgeContext = {
-      warningResponse: { decision: "allow", matches: [] },
-      toolName: "bash",
-      outcome: { success: true, durationMs: 10 },
-      cwdMatchedAtPretool: true,
-      diffPresent: false,
-      tenantId: "local",
-    };
-    await posttool(mockPayload, ctx);
-    expect(mockPosttool).toHaveBeenCalledOnce();
-    expect(mockFF).toHaveBeenCalledOnce();
-    expect(mockFF).toHaveBeenCalledWith(ctx);
-  });
-
-  it("does not call fireFeedback when judgeCtx is undefined", async () => {
-    mockPosttool.mockClear();
-    const { posttool } = await import("./posttool.js");
-    const { fireFeedback } = await import("./judge.js");
-    const mockFF = fireFeedback as unknown as ReturnType<typeof vi.fn>;
-    mockFF.mockClear();
-
-    await posttool(mockPayload);
-    expect(mockPosttool).toHaveBeenCalledOnce();
-    expect(mockFF).not.toHaveBeenCalled();
-  });
-
-  it("returns Promise<void> (async — awaitable by PostToolUse handler)", async () => {
-    mockPosttool.mockClear();
-    const { posttool } = await import("./posttool.js");
-    const result = posttool(mockPayload);
-    expect(result).toBeInstanceOf(Promise);
-    await result; // resolves to undefined
-  });
-});

package/src/ee/posttool.ts

@@ -1,16 +0,0 @@
-import { getDefaultEEClient } from "./intercept.js";
-import { fireFeedback, type JudgeContext } from "./judge.js";
-import type { PostToolPayload } from "./types.js";
-
-/**
- * Call the EE posttool endpoint using the default client.
- * Returns Promise<void> — awaitable by the PostToolUse hook handler.
- * Errors are swallowed (fire-and-forget semantics preserved inside client).
- *
- * When judgeCtx is provided, also fires deterministic feedback (EE-09)
- * and touch on FOLLOWED matches (EE-10). fireFeedback stays synchronous (B-4 preserved).
- */
-export async function posttool(payload: PostToolPayload, judgeCtx?: JudgeContext): Promise<void> {
-  await getDefaultEEClient().posttool(payload);
-  if (judgeCtx) fireFeedback(judgeCtx);
-}