@gajae-code/coding-agent 0.14.2 → 0.15.0

package/dist/types/extensibility/skills.d.ts

@@ -53,6 +53,8 @@ export declare function loadSkillsFromDir(options: LoadSkillsFromDirOptions): Pr
 export interface LoadSkillsOptions extends SkillsSettings {
     /** Working directory for project-local skills. Default: getProjectDir() */
     cwd?: string;
+    /** Explicit user home for skill discovery. Default: getTrustedHomeDir(). */
+    home?: string;
 }
 /**
  * Load skills from all configured locations.

package/dist/types/gjc-runtime/autoresearch-runtime.d.ts

@@ -0,0 +1,194 @@
+import { type RlmDataContext } from "../autoresearch/data-context";
+import { type EnsureAutoresearchBranchResult } from "../autoresearch/git";
+import { type ParsedHarnessOutput } from "../autoresearch/harness";
+import { AutoresearchRunsStore, type MetricDirection } from "../autoresearch/runs";
+export type AutoresearchMode = "web" | "mixed" | "data";
+export type AutoresearchIntakeKind = "handoff" | "cold";
+export declare const AUTORESEARCH_MODES: Set<AutoresearchMode>;
+export declare const AUTORESEARCH_LEDGER_EVENT_KINDS: readonly ["mission_created", "mode_set", "run_logged", "verdict_issued", "critic_recorded", "mission_cleared"];
+export type AutoresearchLedgerEventKind = (typeof AUTORESEARCH_LEDGER_EVENT_KINDS)[number];
+/** The one mission artifact both intake entrypoints write. */
+export interface AutoresearchMission {
+    objective: string;
+    mode: AutoresearchMode;
+    deliverables: string[];
+    constraints: string[];
+    slug: string;
+    intake: AutoresearchIntakeKind;
+    createdAt: string;
+    updatedAt: string;
+    /** Absolute path of the deep-interview spec consumed by spec intake. */
+    specPath?: string;
+    handedOffAt?: string;
+    /**
+     * Primary metric contract for the mission's harness.
+     *
+     * Optional: a mission that declares none keeps the historical default
+     * (`metric`, lower-is-better). When declared it MUST reach the experiment
+     * config -- otherwise a mission whose research contract is
+     * higher-is-better silently optimizes the wrong direction.
+     */
+    primaryMetric?: string;
+    metricUnit?: string;
+    metricDirection?: MetricDirection;
+}
+export interface AutoresearchPaths {
+    dir: string;
+    missionPath: string;
+    ledgerPath: string;
+    /** Quarantine root for retired missions: `<dir>/retired/<slug>.<timestamp>/`. */
+    retiredRoot: string;
+}
+/** Append-only session ledger row. */
+export interface AutoresearchLedgerEvent {
+    eventId: string;
+    event: AutoresearchLedgerEventKind;
+    timestamp: string;
+    [field: string]: unknown;
+}
+/** Optional per-mission critic pass receipt; evaluator is distinct from the mission agent. */
+export interface AutoresearchCriticReceipt {
+    criticId: string;
+    status: Record<string, unknown>;
+    evidence: string[];
+    caveats: string[];
+    evaluator: string;
+    recordedAt: string;
+}
+/** Structured mission verdict: status is open data, not a pinned enum — terminality is deliberately deferred. */
+export interface AutoresearchVerdictReceipt {
+    receiptId: string;
+    status: Record<string, unknown>;
+    evidence: string[];
+    caveats: string[];
+    evaluator: string;
+    issuedAt: string;
+    criticReceipt?: AutoresearchCriticReceipt;
+}
+export interface AutoresearchCommandResult {
+    status: number;
+    stdout?: string;
+    stderr?: string;
+    intake?: AutoresearchIntakeKind;
+    missionCreated?: boolean;
+}
+export interface AutoresearchReadReceipt {
+    ok: true;
+    exists: boolean;
+    mission?: AutoresearchMission;
+    ledger: AutoresearchLedgerEvent[];
+    paths: AutoresearchPaths;
+    /**
+     * GJC session id the mission state was read from. Callers deriving
+     * session-scoped identity (notably the kernel owner id) MUST use this
+     * instead of re-resolving, so every path agrees on one scope.
+     */
+    sessionId: string;
+}
+export interface AutoresearchWriteReceipt {
+    ok: true;
+    mission: AutoresearchMission;
+    missionPath: string;
+    intake: AutoresearchIntakeKind;
+    ledgerEvent?: AutoresearchLedgerEvent;
+}
+export interface AutoresearchClearReceipt {
+    ok: true;
+    cleared: boolean;
+    missionPath: string;
+    ledgerEvent: AutoresearchLedgerEvent;
+    /** Where the retired mission's artifacts were quarantined, when one existed. */
+    retiredTo?: string;
+}
+export interface AutoresearchIntakeReceipt extends AutoresearchWriteReceipt {
+    specPath: string;
+}
+export declare function getAutoresearchPaths(cwd: string, sessionId?: string | null): AutoresearchPaths;
+export declare function readAutoresearchMission(cwd: string, sessionId?: string | null): Promise<AutoresearchMission | null>;
+export declare function readAutoresearchLedger(cwd: string, sessionId?: string | null): Promise<AutoresearchLedgerEvent[]>;
+/** read verb: current mission + append-only ledger snapshot. */
+export declare function autoresearchRead(cwd: string, sessionId?: string | null): Promise<AutoresearchReadReceipt>;
+/** write verb: persist the mission after cold-intake clarification. Mode is required. */
+export declare function autoresearchWrite(input: {
+    cwd: string;
+    objective: string;
+    mode: AutoresearchMode;
+    deliverables?: string[];
+    constraints?: string[];
+    slug: string;
+    sessionId?: string | null;
+    primaryMetric?: string;
+    metricUnit?: string;
+    metricDirection?: string;
+}): Promise<AutoresearchWriteReceipt>;
+/**
+ * clear verb: retire the entire mission working set and record the mission clear.
+ *
+ * Artifacts are QUARANTINED to `<dir>/retired/<slug>.<timestamp>/`, never
+ * deleted, so a completed mission's evidence stays auditable while the
+ * successor mission starts from genuinely empty state. The `mission_cleared` row
+ * is appended to the OUTGOING ledger before it is moved, so the retired ledger
+ * is a complete record that ends with its own clear and the successor's ledger
+ * starts empty rather than the clear silently vanishing from the audit trail.
+ */
+export declare function autoresearchClear(cwd: string, sessionId?: string | null): Promise<AutoresearchClearReceipt>;
+/** Spec intake (`intake --spec <path>` or bare `--spec`): read the spec, write the mission, ask zero questions. The persisted intake kind stays "handoff" (seeded by a deep-interview handoff). */
+export declare function autoresearchIntake(input: {
+    cwd: string;
+    specPath: string;
+    sessionId?: string | null;
+}): Promise<AutoresearchIntakeReceipt>;
+/** Record one experiment run in the ledger. */
+export declare function autoresearchLogRun(input: {
+    cwd: string;
+    runId: string;
+    status: string;
+    description: string;
+    metric?: number;
+    slug?: string;
+    sessionId?: string | null;
+}): Promise<AutoresearchLedgerEvent>;
+/** Record the optional per-mission critic pass; its evaluator is distinct from the mission agent. */
+export declare function autoresearchRecordCritic(input: {
+    cwd: string;
+    status: Record<string, unknown>;
+    evidence: string[];
+    caveats: string[];
+    evaluator: string;
+    slug?: string;
+    sessionId?: string | null;
+}): Promise<AutoresearchCriticReceipt>;
+/** Issue the mission verdict; an optional critic receipt rides along with its own evaluator identity. */
+export declare function autoresearchIssueVerdict(input: {
+    cwd: string;
+    status: Record<string, unknown>;
+    evidence: string[];
+    caveats: string[];
+    evaluator: string;
+    criticReceipt?: AutoresearchCriticReceipt;
+    slug?: string;
+    sessionId?: string | null;
+}): Promise<AutoresearchVerdictReceipt>;
+export declare function runNativeAutoresearchCommand(args: string[], cwd?: string): Promise<AutoresearchCommandResult>;
+/**
+ * Rebuilt autoresearch capability surface. Each capability is reachable from
+ * the runtime through a thin, mission-state-aware wrapper. All are read-only
+ * with respect to the ledger — none append events; the verbs above remain the
+ * only writers.
+ */
+/** 1. Branch isolation: ensure the worktree is on an `autoresearch/*` branch. */
+export declare function autoresearchBranchIsolation(cwd: string, goal: string): Promise<EnsureAutoresearchBranchResult>;
+/** 2. Harness contract: parse `METRIC`/`ASI` lines out of captured harness output. */
+export declare function autoresearchHarnessOutput(output: string, primaryMetricName?: string): ParsedHarnessOutput;
+/**
+ * 3. Durable run storage: open the session-scoped JSONL run store, seeding an
+ * in-memory experiment config from the mission when none is persisted yet.
+ */
+export declare function autoresearchRunsStore(cwd: string, sessionId?: string | null): Promise<AutoresearchRunsStore>;
+/** 4. TUI dashboard: render the run table (collapsed + expanded) from persisted state. */
+export declare function autoresearchDashboardText(cwd: string, sessionId?: string | null, width?: number): Promise<string>;
+export declare function autoresearchDataContext(cwd: string, dataFlag?: string, sessionId?: string | null): Promise<RlmDataContext | null>;
+/** 8. Two-phase prompts: Phase 1 (harness setup) rendered from mission/branch state. */
+export declare function autoresearchSetupPrompt(baseSystemPrompt: string, cwd: string, goal?: string, sessionId?: string | null): Promise<string>;
+/** 8. Two-phase prompts: Phase 2 (iterate) rendered from the persisted experiment state. */
+export declare function autoresearchIteratePrompt(baseSystemPrompt: string, cwd: string, sessionId?: string | null): Promise<string>;

package/dist/types/gjc-runtime/gc-runtime.d.ts

@@ -13,7 +13,7 @@
  * - Dry-run by default: nothing is deleted unless `--prune`/`--force`.
  */
 import { type GcSessionScopeUsage } from "./gc-session-scope";
-export type GcStore = "harness_leases" | "team_workers" | "file_locks" | "tmux_sessions" | "registry_entries" | "local_roots";
+export type GcStore = "harness_leases" | "file_locks" | "tmux_sessions" | "registry_entries" | "local_roots";
 export declare const GC_STORES: readonly GcStore[];
 /** Why a probed pid is kept instead of treated as dead. */
 export type GcPidKeepReason = "alive" | "eperm" | "unknown";

package/dist/types/gjc-runtime/psmux-detect.d.ts

@@ -65,7 +65,7 @@ export interface ResolvedTmuxBinary {
 }
 /**
  * Resolve the tmux command GJC should invoke. Honors the existing
- * GJC_TMUX_COMMAND / GJC_TEAM_TMUX_COMMAND overrides; on Windows when no
+ * GJC_TMUX_COMMAND override; on Windows when no
  * override is set, psmux (installed as psmux, pmux, or tmux) is picked
  * automatically so the default gjc --tmux flow lands on a real multiplexer.
  */

package/dist/types/gjc-runtime/python-transcript.d.ts

@@ -0,0 +1,19 @@
+export interface PythonTranscriptRecord {
+    timestamp: string;
+    code: string;
+    output: string;
+    exitCode: number | null;
+    cancelled: boolean;
+    truncated: boolean;
+}
+export interface PythonKernelTranscript {
+    readonly dir: string;
+    readonly kernelInstanceId: string;
+    append(record: PythonTranscriptRecord): Promise<void>;
+}
+export declare function openPythonKernelTranscript(input: {
+    cwd: string;
+    sessionId: string;
+    kernelInstanceId: string;
+    now?: Date;
+}): PythonKernelTranscript;

package/dist/types/gjc-runtime/ralplan-runtime.d.ts

@@ -14,7 +14,7 @@ import { type RalplanIndexRow } from "./ledger-event-renderer";
  * 2. **Artifact write**: `gjc ralplan --write --stage <type> --stage_n <N>
  *    (--artifact <path-or-string> | --artifact-env GJC_RALPLAN_ARTIFACT)
  *    [--run-id <id>] [--session-id <id>] [--lane-verdict <token>] [--json]` persists Planner / Architect
- *    / Critic / disposition / revision / post-interview / ADR / final artifacts under
+ *    / Critic / intent / disposition / revision / post-interview / ADR / final artifacts under
  *    `.gjc/plans/ralplan/<run-id>/`, maintains an `index.jsonl` audit log, copies `final`
  *    stages to `pending-approval.md`, and advances the HUD chip to reflect the latest
  *    persisted stage. Disposition stage artifacts are fail-closed JSON documents that
@@ -35,7 +35,7 @@ export declare const PLANNING_STUCK_MARKER = "PLANNING-STUCK";
 export declare const RALPLAN_DEFAULT_MAX_REVIEW_PASSES_PER_LANE = 1;
 /** Inclusive upper bound for `gjc.ralplan.maxReviewPassesPerLane` settings overrides. */
 export declare const RALPLAN_MAX_REVIEW_PASSES_PER_LANE_LIMIT = 10;
-export type RalplanAutoHandoffTarget = "off" | "ultragoal" | "team";
+export type RalplanAutoHandoffTarget = "off" | "ultragoal" | "autoresearch";
 export interface RalplanAutoHandoffResolution {
     configuredTarget: RalplanAutoHandoffTarget;
     effectiveTarget: RalplanAutoHandoffTarget;
@@ -139,12 +139,6 @@ export declare function resolveRalplanMaxIterations(cwd: string, agentDir?: stri
 }>;
 type RalplanAutoHandoffOptions = {
     planningStuck?: boolean;
-    teamAvailabilityProbe?: () => {
-        available: true;
-    } | {
-        available: false;
-        reason: string;
-    };
     /** The session's effective agent directory (see resolveWorkflowSetting). */
     agentDir?: string;
 };

package/dist/types/gjc-runtime/session-layout.d.ts

@@ -44,16 +44,19 @@ export declare function sessionAuditDir(cwd: string, gjcSessionId: string): stri
 export declare function sessionReportsDir(cwd: string, gjcSessionId: string): string;
 export declare function sessionLogsDir(cwd: string, gjcSessionId: string): string;
 export declare function sessionRuntimeDir(cwd: string, gjcSessionId: string): string;
-export declare function sessionRlmDir(cwd: string, gjcSessionId: string): string;
+export declare function sessionIpykernelsDir(cwd: string, gjcSessionId: string): string;
+export declare function sessionIpykernelsArtifactsDir(cwd: string, gjcSessionId: string): string;
+export declare function pythonKernelTranscriptPath(cwd: string, gjcSessionId: string, dirName: string): string;
+export declare function sessionAutoresearchDir(cwd: string, gjcSessionId: string): string;
+export declare function sessionAutoresearchRunsDir(cwd: string, gjcSessionId: string): string;
 export declare function activeStateDir(cwd: string, gjcSessionId: string): string;
 export declare function activeSnapshotPath(cwd: string, gjcSessionId: string): string;
 export declare function activeEntryPath(cwd: string, gjcSessionId: string, skill: string): string;
 export declare function modeStatePath(cwd: string, gjcSessionId: string, mode: string): string;
 export declare function auditPath(cwd: string, gjcSessionId: string): string;
 export declare function transactionJournalPath(cwd: string, gjcSessionId: string, mutationId: string): string;
-export declare function teamStateRoot(cwd: string, gjcSessionId: string): string;
 export declare function workflowGatePath(cwd: string, gjcSessionId: string, gateId: string): string;
 export declare function harnessStateRoot(cwd: string, gjcSessionId: string): string;
 export declare function coordinatorMcpStateRoot(cwd: string, gjcSessionId: string): string;
 export declare function tmuxRuntimeSessionPath(cwd: string, gjcSessionId: string, slug: string): string;
-export declare function rlmArtifactRoot(cwd: string, gjcSessionId: string, rlmSessionId: string): string;
+export declare function autoresearchRlmArtifactRoot(cwd: string, gjcSessionId: string, rlmSessionId: string): string;

package/dist/types/gjc-runtime/state-renderer.d.ts

@@ -45,26 +45,4 @@ export declare function renderUltragoalStatusMarkdown(summary: {
     nudgeGoalId?: string;
     nudgeTargetKind?: string;
 }): string;
-export declare function renderTeamStatusMarkdown(snapshot: {
-    team_name: string;
-    phase: string;
-    tmux_target?: string;
-    tmux_session?: string;
-    state_dir: string;
-    task_total: number;
-    task_counts: Record<string, number>;
-    workers: Array<{
-        id: string;
-        status: string;
-    }>;
-    notification_summary?: {
-        total: number;
-        replay_eligible: number;
-        by_state: Record<string, number>;
-    };
-    integration_by_worker?: Record<string, {
-        status?: string;
-        conflict_files?: string[];
-    }>;
-}): string;
 export declare function renderStateMarkdown(skill: CanonicalGjcWorkflowSkill, stateJson: Record<string, unknown>, manifest: SkillManifest): string;

package/dist/types/gjc-runtime/state-schema.d.ts

@@ -9,9 +9,9 @@ export declare const WorkflowStateContentChecksumSchema: z.ZodObject<{
 export declare const WorkflowStateReceiptSchema: z.ZodObject<{
     version: z.ZodNumber;
     skill: z.ZodEnum<{
+        autoresearch: "autoresearch";
         "deep-interview": "deep-interview";
         ralplan: "ralplan";
-        team: "team";
         ultragoal: "ultragoal";
     }>;
     owner: z.ZodEnum<{
@@ -52,9 +52,9 @@ export declare const WorkflowStateEnvelopeSchema: z.ZodObject<{
     receipt: z.ZodOptional<z.ZodObject<{
         version: z.ZodNumber;
         skill: z.ZodEnum<{
+            autoresearch: "autoresearch";
             "deep-interview": "deep-interview";
             ralplan: "ralplan";
-            team: "team";
             ultragoal: "ultragoal";
         }>;
         owner: z.ZodEnum<{
@@ -93,9 +93,9 @@ export declare const WorkflowStateEnvelopeSchema: z.ZodObject<{
 export declare const RequiredWorkflowStateReceiptSchema: z.ZodObject<{
     version: z.ZodNumber;
     skill: z.ZodEnum<{
+        autoresearch: "autoresearch";
         "deep-interview": "deep-interview";
         ralplan: "ralplan";
-        team: "team";
         ultragoal: "ultragoal";
     }>;
     owner: z.ZodEnum<{
@@ -126,9 +126,9 @@ export declare const RequiredWorkflowStateReceiptSchema: z.ZodObject<{
  */
 export declare const RequiredOnWriteEnvelopeSchema: z.ZodObject<{
     skill: z.ZodEnum<{
+        autoresearch: "autoresearch";
         "deep-interview": "deep-interview";
         ralplan: "ralplan";
-        team: "team";
         ultragoal: "ultragoal";
     }>;
     version: z.ZodLiteral<2>;
@@ -138,9 +138,9 @@ export declare const RequiredOnWriteEnvelopeSchema: z.ZodObject<{
     receipt: z.ZodObject<{
         version: z.ZodNumber;
         skill: z.ZodEnum<{
+            autoresearch: "autoresearch";
             "deep-interview": "deep-interview";
             ralplan: "ralplan";
-            team: "team";
             ultragoal: "ultragoal";
         }>;
         owner: z.ZodEnum<{
@@ -196,9 +196,9 @@ export declare const SkillActiveEntrySchema: z.ZodObject<{
     receipt: z.ZodOptional<z.ZodObject<{
         version: z.ZodNumber;
         skill: z.ZodEnum<{
+            autoresearch: "autoresearch";
             "deep-interview": "deep-interview";
             ralplan: "ralplan";
-            team: "team";
             ultragoal: "ultragoal";
         }>;
         owner: z.ZodEnum<{
@@ -257,9 +257,9 @@ export declare const SkillActiveStateSchema: z.ZodObject<{
         receipt: z.ZodOptional<z.ZodObject<{
             version: z.ZodNumber;
             skill: z.ZodEnum<{
+                autoresearch: "autoresearch";
                 "deep-interview": "deep-interview";
                 ralplan: "ralplan";
-                team: "team";
                 ultragoal: "ultragoal";
             }>;
             owner: z.ZodEnum<{

package/dist/types/gjc-runtime/tmux-common.d.ts

@@ -33,14 +33,14 @@ export declare function envDisabled(value: string | undefined): boolean;
  * Resolve the tmux (or tmux-compatible multiplexer) command GJC should invoke.
  *
  * This is the shared entry point used by every GJC code path that needs to talk
- * to a multiplexer: `gjc --tmux` planning, `gjc session ...`, `gjc team ...`,
+ * to a multiplexer: `gjc --tmux` planning and `gjc session ...`,
  * the lifecycle controller, and the harness resident owner. Routing all of
  * them through the same resolver means a single `GJC_TMUX_COMMAND` override or
  * a single Windows psmux / pmux detection wins for the whole process — the
  * failure mode where `gjc --tmux` creates a psmux-backed session and then
  * `gjc session status` fails because it queries literal `tmux` is closed off.
  *
- * Explicit `GJC_TMUX_COMMAND` / `GJC_TEAM_TMUX_COMMAND` overrides are honored on
+ * Explicit `GJC_TMUX_COMMAND` overrides are honored on
  * every platform. On native Windows without an override the resolver walks
  * `psmux`, then `pmux`, then `tmux` and uses the first binary present on PATH.
  * On POSIX the resolver returns `tmux` (the historical default) and only

package/dist/types/gjc-runtime/ultragoal-change-set.d.ts

@@ -1,4 +1,30 @@
-import { type UltragoalChangeSet, type UltragoalChangeSetPath } from "./ultragoal-runtime";
+export type UltragoalChangeStatus = "added" | "modified" | "deleted" | "renamed" | "copied" | "unknown";
+export type UltragoalChangeCategory = "code" | "generated-binding" | "tool" | "settings-registry" | "prompt-doc-behavior" | "docs-static" | "other";
+export interface UltragoalChangeSetPath {
+    path: string;
+    status: UltragoalChangeStatus;
+    oldPath?: string;
+    category?: UltragoalChangeCategory;
+    [key: string]: unknown;
+}
+export interface UltragoalChangeSet {
+    source: "checkpoint-git" | "review-pr" | "review-branch" | "review-worktree" | "review-spec";
+    baseRef?: string;
+    headRef?: string;
+    mergeBase?: string;
+    paths: UltragoalChangeSetPath[];
+    rawDiffStat?: string;
+    rawDiff?: string;
+    untrackedContentHash?: string;
+    untrackedContentHashVerified?: boolean;
+    captureIncomplete?: boolean;
+    trusted: true;
+    [key: string]: unknown;
+}
+export declare function normalizeRepoPath(value: string): string;
+export declare function normalizeChangeSetPath(value: string): string;
+export declare function categorizeComputerChangePath(pathValue: string): UltragoalChangeCategory;
+export declare function computeUltragoalReviewSourceHash(changeSet: UltragoalChangeSet | undefined): string | undefined;
 export declare function spawnText(command: string[], options: {
     cwd: string;
     timeoutMs?: number;
@@ -13,4 +39,15 @@ export declare function parseGitUntrackedPaths(output: string): UltragoalChangeS
 export declare function ciDevChangedPathRows(): UltragoalChangeSetPath[];
 export declare function mergeChangeSetPaths(groups: UltragoalChangeSetPath[][]): UltragoalChangeSetPath[];
 export declare function computeCheckpointChangeSet(cwd: string): Promise<UltragoalChangeSet | undefined>;
+/**
+ * A content witness of overall repository state. HEAD and porcelain status are
+ * retained for cheap structural diagnostics, but the authoritative comparison
+ * also digests every tracked and non-ignored untracked path. A same-status edit
+ * therefore cannot pass the capture boundary merely because Git's status text
+ * stayed unchanged.
+ */
+type RepositoryStateWitnessTestHook = (phase: "after-initial", cwd: string) => void | Promise<void>;
+/** @internal Test-only seam; production capture has no injected mutation hook. */
+export declare function __setRepositoryStateWitnessTestHookForTests(hook: RepositoryStateWitnessTestHook | undefined): void;
 export declare function parseUnifiedDiffPaths(diff: string): UltragoalChangeSetPath[];
+export {};

package/dist/types/gjc-runtime/ultragoal-runtime.d.ts

@@ -2,6 +2,8 @@ import type { WorkflowHudSummary } from "../skill-state/active-state";
 import { type RepositoryBinding } from "./repository-binding";
 import { type CriticVerdict } from "./ultragoal-receipt-freshness";
 export { CRITIC_GATE_HARD_STOP_EVENT, CRITIC_GATE_OVERRIDE_EVENT, CRITIC_VERDICT_EVENT, type CriticVerdict, computeUltragoalPlanGeneration, countTerminalCriticVerdicts, receiptRelevantGoals, TERMINAL_CRITIC_CEILING, terminalCriticCeilingReached, terminalCriticGateOverridden, } from "./ultragoal-receipt-freshness";
+import { type UltragoalChangeSet } from "./ultragoal-change-set";
+export { categorizeComputerChangePath, ciDevChangedPathRows, computeCheckpointChangeSet, computeUltragoalReviewSourceHash, mergeChangeSetPaths, normalizeChangeSetPath, normalizeRepoPath, parseGitNameStatus, parseGitUntrackedPaths, parseUnifiedDiffPaths, resolveGitBase, spawnText, type UltragoalChangeCategory, type UltragoalChangeSet, type UltragoalChangeSetPath, type UltragoalChangeStatus, } from "./ultragoal-change-set";
 export { captureUltragoalRecoverySnapshot, parseStrictTerminalTranscript, persistUltragoalRecoveryDecision, planUltragoalOwnerLossRecovery, type UltragoalOwnerLossReceipt, type UltragoalRecoveryBinding, type UltragoalRecoveryDecision, type UltragoalRecoverySnapshot, validateOwnerLossBinding, validateRawUltragoalEvidence, validateRecoveryAdmission, validateRecoveryPath, } from "./ultragoal-owner-loss-recovery";
 export type UltragoalGjcGoalMode = "aggregate" | "per-story";
 export type UltragoalGoalStatus = "pending" | "active" | "complete" | "failed" | "blocked" | "review_blocked" | "superseded";
@@ -287,28 +289,6 @@ export declare function requireResolvedLinks(ids: string[], map: Map<string, Jso
 export declare function normalizedEvidenceKind(row: JsonObject): string;
 export declare function evidenceKindMatches(kind: string, words: string[]): boolean;
 export type SurfaceFamily = "web" | "cli" | "native" | "api-package" | "algorithm-math" | "unknown";
-export type UltragoalChangeStatus = "added" | "modified" | "deleted" | "renamed" | "copied" | "unknown";
-export type UltragoalChangeCategory = "code" | "generated-binding" | "tool" | "settings-registry" | "prompt-doc-behavior" | "docs-static" | "other";
-export interface UltragoalChangeSetPath extends JsonObject {
-    path: string;
-    status: UltragoalChangeStatus;
-    oldPath?: string;
-    category?: UltragoalChangeCategory;
-}
-export interface UltragoalChangeSet extends JsonObject {
-    source: "checkpoint-git" | "review-pr" | "review-branch" | "review-worktree" | "review-spec";
-    baseRef?: string;
-    headRef?: string;
-    mergeBase?: string;
-    paths: UltragoalChangeSetPath[];
-    rawDiffStat?: string;
-    rawDiff?: string;
-    captureIncomplete?: boolean;
-    trusted: true;
-}
-export declare function normalizeRepoPath(value: string): string;
-export declare function normalizeChangeSetPath(value: string): string;
-export declare function categorizeComputerChangePath(value: string): UltragoalChangeCategory;
 export declare function normalizeSurfaceToken(value: string): string;
 export declare function surfaceFamily(value: string): SurfaceFamily;
 export declare function isLiveSurfaceFamily(family: SurfaceFamily): boolean;
@@ -426,8 +406,6 @@ interface UltragoalReviewResult extends JsonObject {
     weakContractCapApplied: boolean;
     blockerGoalIds?: string[];
 }
-import { ciDevChangedPathRows, computeCheckpointChangeSet, mergeChangeSetPaths, parseGitNameStatus, parseGitUntrackedPaths, parseUnifiedDiffPaths, resolveGitBase, spawnText } from "./ultragoal-change-set";
-export { ciDevChangedPathRows, computeCheckpointChangeSet, mergeChangeSetPaths, parseGitNameStatus, parseGitUntrackedPaths, parseUnifiedDiffPaths, resolveGitBase, spawnText, };
 /**
  * Typed terminal handoff thrown when {@link recordUltragoalReviewBlockers} would
  * exceed {@link MAX_REVIEW_BLOCKER_DESCENTS} unresolved review_blocker descents

package/dist/types/gjc-runtime/ultragoal-validation-policy.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Deterministic Ultragoal validation applicability policy (#4560).
+ *
+ * The boundary cohort (`cleaner || architect || QA`) and the terminal critic
+ * are expensive LLM lanes. They were introduced as unconditional per-boundary
+ * ceremony, which inflates token cost and failure surface on low-risk work and
+ * makes compaction more likely during long runs (#3473/#3474 moved review from
+ * per-subgoal to per-boundary; this policy makes the boundary lanes
+ * risk-proportional without removing them for risky work).
+ *
+ * Selection is runtime-authoritative and deterministic from durable facts
+ * (change set, plan shape, ledger receipts) — never free-form model prose.
+ * It fails closed: any condition that cannot be proven cheap is treated as
+ * high-risk and keeps the full heavyweight cohort. The precedent is
+ * `requiresComputerRedTeamSuite`, whose applicability the runtime derives from
+ * the computed change set and refuses to let the model self-exempt.
+ */
+import { type UltragoalChangeSet, type UltragoalChangeSetPath } from "./ultragoal-change-set";
+export type UltragoalValidationLane = "cleaner" | "architect" | "qa" | "terminal-critic";
+export interface UltragoalValidationApplicabilityInput {
+    /** Trusted computed change set for the boundary (checkpoint path). */
+    changeSet?: UltragoalChangeSet;
+    /**
+     * Durable aggregate shape: the number of goals the plan actually requires.
+     * This is a property of the plan, not of how far it has progressed, so the
+     * multi-goal risk signal cannot evaporate at the final goal of a multi-goal
+     * run — which is precisely the aggregate boundary where risk is highest.
+     */
+    requiredGoals?: number;
+    /** Open review blockers exist (review_blocked goals). */
+    hasOpenReviewBlockers?: boolean;
+    /** Newest joined cohort sourceHash recorded in the ledger. */
+    latestCohortSourceHash?: string;
+    /** Current frozen source hash the boundary would review. */
+    currentSourceHash?: string;
+    /** Runtime-computed digest of the authoritative current source basis. */
+    authoritativeSourceHash?: string;
+}
+export interface UltragoalValidationApplicability {
+    /** Lane -> applicability decision with the durable facts that forced it. */
+    lanes: Record<UltragoalValidationLane, {
+        applicable: boolean;
+        reasons: string[];
+    }>;
+    /** True only when every heavyweight lane is applicable (full cohort). */
+    heavyweight: boolean;
+    /** Risk classification driving the selection. */
+    riskClass: "low" | "high";
+    /** True when open review blockers make terminal evidence uncertain. */
+    hasOpenReviewBlockers: boolean;
+    /** True when an unchanged immutable source basis permits evidence reuse. */
+    basisUnchanged: boolean;
+    /** Human- and machine-inspectable selection basis, recorded in diagnostics. */
+    selection: string[];
+}
+export interface UltragoalValidationLaneSelection {
+    riskClass: "low" | "high";
+    reasons: string[];
+    omittedLanes: UltragoalValidationLane[];
+}
+export declare function isHighRiskChangePath(row: UltragoalChangeSetPath): boolean;
+export declare function validationLaneSelectionFor(applicability: UltragoalValidationApplicability): UltragoalValidationLaneSelection;
+export declare function isMigrationChangePath(row: UltragoalChangeSetPath): boolean;
+/**
+ * Compute the deterministic validation applicability for a boundary.
+ *
+ * Low-risk eligibility (the only case where redundant lanes may be omitted):
+ * trusted change set, single outstanding goal, no open review blockers, no
+ * high-risk/migration/computer/public-contract path, complete capture.
+ * Everything else — including a missing/untrusted change set — keeps the full
+ * heavyweight cohort exactly as today.
+ */
+export declare function resolveUltragoalValidationApplicability(input: UltragoalValidationApplicabilityInput): UltragoalValidationApplicability;