@patronage/software-factory 1.0.0-alpha.35 → 1.0.0-alpha.36

package/README.md

@@ -76,4 +76,6 @@ npx skills add https://github.com/patronage/software-factory -g --all
 
 They provide procedure and link back to the documentation site; they are not a second command reference.
 
+The package also exports an Oxlint plugin at `@patronage/software-factory/oxlint-jev`. It asks Jev questions that a project writes about its own code, through HQ, from a dedicated Oxlint config. It records by default and sends only with `PATRONAGE_JEV_MODE=live`. `psf jev:calibrate` scores those questions against the project's labeled cases. Both are session diagnostics, never gates. See [Ask Jev about code](https://factory.patronage.com/how-to/ask-jev-about-code).
+
 `assembleReviewPrompt` puts a repository-root `CODING_STANDARDS.md` into the correctness prompt when the file exists and is not blank. It reads the file at the candidate head, not from the working tree, and emits one `coding-standards` section that names the head SHA. A repository without the file gets an unchanged prompt. `pr:review --assemble` writes that factory-owned prompt under `.factory-memory/pr-review-prompt.json`. `pr:review --findings` copies the recorded sections onto the proof when the artifact's patch-id matches.

package/dist/{chunk-pbuEa-1d.js → chunk-DrSxFLj_.js}

@@ -1,3 +1,4 @@
+import "node:module";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import { Command } from "commander";
 import { z } from "zod";
 import { existsSync, readFileSync, rmSync } from "node:fs";
 import { PreviewProofRegistration } from "@patronage/factory-ci";
+import { JsonValue, Questions, SystemOneRequest, choice, noul, score } from "@typesafe-ai/sdk";
 
 //#region src/review-rungs.d.ts
 declare const EVIDENCE_REVIEW_RUNGS: readonly ["independent-model", "oracle", "human"];
@@ -1659,8 +1660,8 @@ declare const mergeFreezeStateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   generationId: z.ZodNumber;
   headSha: z.ZodString;
   outcome: z.ZodEnum<{
-    active: "active";
     stale: "stale";
+    active: "active";
   }>;
   reason: z.ZodString;
   recordedAt: z.ZodISODateTime;
@@ -1668,9 +1669,9 @@ declare const mergeFreezeStateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   verification: z.ZodOptional<z.ZodObject<{
     jobs: z.ZodRecord<z.ZodString, z.ZodEnum<{
       success: "success";
+      skipped: "skipped";
       failure: "failure";
       cancelled: "cancelled";
-      skipped: "skipped";
     }>>;
     runAttempt: z.ZodNumber;
     runId: z.ZodNumber;
@@ -1687,9 +1688,9 @@ declare const mergeFreezeStateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   verification: z.ZodOptional<z.ZodObject<{
     jobs: z.ZodRecord<z.ZodString, z.ZodEnum<{
       success: "success";
+      skipped: "skipped";
       failure: "failure";
       cancelled: "cancelled";
-      skipped: "skipped";
     }>>;
     runAttempt: z.ZodNumber;
     runId: z.ZodNumber;
@@ -1948,10 +1949,10 @@ declare const managedReadinessLedgerSchema: z.ZodObject<{
       reviewedHeadSha: z.ZodOptional<z.ZodString>;
       reviewedPatchId: z.ZodOptional<z.ZodString>;
       status: z.ZodEnum<{
-        stale: "stale";
         "not-required": "not-required";
         blocked: "blocked";
         current: "current";
+        stale: "stale";
         missing: "missing";
       }>;
     }, z.core.$strip>;
@@ -1960,10 +1961,10 @@ declare const managedReadinessLedgerSchema: z.ZodObject<{
       reviewedHeadSha: z.ZodOptional<z.ZodString>;
       reviewedPatchId: z.ZodOptional<z.ZodString>;
       status: z.ZodEnum<{
-        stale: "stale";
         "not-required": "not-required";
         blocked: "blocked";
         current: "current";
+        stale: "stale";
         missing: "missing";
       }>;
     }, z.core.$strip>>;
@@ -2933,10 +2934,10 @@ declare const loadEvidenceEnvelopes: (cwd: string) => LoadedEvidenceEnvelope[];
 //#region src/review-proof-applicability.d.ts
 declare const REVIEW_STATUS_VALUES: readonly ["not-required", "current", "stale", "missing", "blocked"];
 declare const reviewStatusSchema: z.ZodEnum<{
-  stale: "stale";
   "not-required": "not-required";
   blocked: "blocked";
   current: "current";
+  stale: "stale";
   missing: "missing";
 }>;
 type ReviewStatus = z.infer<typeof reviewStatusSchema>;
@@ -3715,18 +3716,18 @@ declare const LegacyWorkerCloseoutStatusTraceEventSchema: z.ZodObject<{
   threadId: z.ZodOptional<z.ZodString>;
   workerId: z.ZodOptional<z.ZodString>;
   archiveStatus: z.ZodOptional<z.ZodEnum<{
-    skipped: "skipped";
     unavailable: "unavailable";
     archived: "archived";
+    skipped: "skipped";
     "not-applicable": "not-applicable";
     pending: "pending";
   }>>;
   closeoutReason: z.ZodOptional<z.ZodString>;
   eventType: z.ZodLiteral<"worker-closeout-lessons">;
   lessonStatus: z.ZodOptional<z.ZodEnum<{
-    skipped: "skipped";
     captured: "captured";
     unavailable: "unavailable";
+    skipped: "skipped";
   }>>;
   lessonSummary: z.ZodOptional<z.ZodString>;
   typeVersion: z.ZodLiteral<2>;
@@ -4113,18 +4114,18 @@ declare const FACTORY_TRACE_EVENT_DEFINITIONS: readonly [DefinedTraceEvent<"revi
   threadId: z.ZodOptional<z.ZodString>;
   workerId: z.ZodOptional<z.ZodString>;
   archiveStatus: z.ZodOptional<z.ZodEnum<{
-    skipped: "skipped";
     unavailable: "unavailable";
     archived: "archived";
+    skipped: "skipped";
     "not-applicable": "not-applicable";
     pending: "pending";
   }>>;
   closeoutReason: z.ZodOptional<z.ZodString>;
   eventType: z.ZodLiteral<"worker-closeout-lessons">;
   lessonStatus: z.ZodOptional<z.ZodEnum<{
-    skipped: "skipped";
     captured: "captured";
     unavailable: "unavailable";
+    skipped: "skipped";
   }>>;
   lessonSummary: z.ZodOptional<z.ZodString>;
   typeVersion: z.ZodLiteral<2>;
@@ -4154,17 +4155,17 @@ declare const FACTORY_TRACE_EVENT_DEFINITIONS: readonly [DefinedTraceEvent<"revi
   }, z.core.$strict>], "lessonStatus">;
   readonly 2: z.ZodObject<{
     archiveStatus: z.ZodOptional<z.ZodEnum<{
-      skipped: "skipped";
       unavailable: "unavailable";
       archived: "archived";
+      skipped: "skipped";
       "not-applicable": "not-applicable";
       pending: "pending";
     }>>;
     closeoutReason: z.ZodOptional<z.ZodString>;
     lessonStatus: z.ZodOptional<z.ZodEnum<{
-      skipped: "skipped";
       captured: "captured";
       unavailable: "unavailable";
+      skipped: "skipped";
     }>>;
     lessonSummary: z.ZodOptional<z.ZodString>;
     observedAt: z.ZodString;
@@ -4852,13 +4853,13 @@ declare const evaluateReadiness: (input: EvaluationInput) => {
     reviews: {
       correctness: {
         required: boolean;
-        status: "stale" | "not-required" | "blocked" | "current" | "missing";
+        status: "not-required" | "blocked" | "current" | "stale" | "missing";
         reviewedHeadSha?: string | undefined;
         reviewedPatchId?: string | undefined;
       };
       security?: {
         required: boolean;
-        status: "stale" | "not-required" | "blocked" | "current" | "missing";
+        status: "not-required" | "blocked" | "current" | "stale" | "missing";
         reviewedHeadSha?: string | undefined;
         reviewedPatchId?: string | undefined;
       } | undefined;
@@ -5334,6 +5335,275 @@ declare function assertWorkerCheckoutAllowed({
   probe?: CheckoutDirsProbe;
 }): void;
 //#endregion
+//#region src/jev/schema.d.ts
+/** The request body this package sends. No `model` field, ever: HQ names it. */
+type JevRequestBody = Pick<SystemOneRequest, "state" | "questions">;
+/**
+ * One answer, discriminated exactly as Jev discriminates it.
+ *
+ * Every member is a *stripping* object: an unknown key inside one answer is
+ * dropped, not an error. Erroring would let a single surprising field sink a
+ * whole response, and keeping it would put an upstream-named field into a
+ * record. Dropping is the only behavior that is both safe and non-destructive.
+ */
+declare const jevAnswerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  noul: z.ZodNumber;
+  type: z.ZodLiteral<"noul">;
+}, z.core.$strip>, z.ZodObject<{
+  choice: z.ZodString;
+  confidence: z.ZodNumber;
+  probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+  type: z.ZodLiteral<"choice">;
+}, z.core.$strip>, z.ZodObject<{
+  confidence: z.ZodNumber;
+  probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+  score: z.ZodNumber;
+  type: z.ZodLiteral<"score">;
+}, z.core.$strip>], "type">;
+type JevAnswer = z.infer<typeof jevAnswerSchema>;
+interface JevUsage {
+  input_tokens?: number;
+  output_tokens?: number;
+}
+interface JevResponse {
+  answers: Record<string, JevAnswer>;
+  /** The model HQ ran, or `unknown` when what it returned is not an id. */
+  model: string;
+  usage?: JevUsage;
+}
+/** What a report says when HQ names its model in something other than an id. */
+declare const UNKNOWN_MODEL = "unknown";
+/**
+ * A question set keyed by the names its answers come back under. Re-stated as a
+ * value type so adapters can build one incrementally without importing the
+ * SDK.
+ */
+type JevQuestions = Questions;
+type JevJsonValue = JsonValue;
+//#endregion
+//#region src/jev/cache.d.ts
+/**
+ * The request-hash cache: the same request bytes against the same endpoint
+ * answer from disk instead of from HQ.
+ *
+ * The key is the endpoint plus the exact serialized request, and nothing else.
+ * That is the whole design: a changed snippet, a reworded question, a
+ * different reference file and a different HQ all move the bytes, so they all
+ * move the key. There is no key schema to keep in step with the request
+ * builder, and no way to grow one that forgets a field.
+ *
+ * It lives under `node_modules/.cache`, which is disposable by convention and
+ * already ignored everywhere — a Jev answer is a session diagnostic (ADR
+ * 0034), not a build input and not evidence.
+ *
+ * An entry that exists but cannot be used — unreadable, not JSON, not Jev's
+ * response shape — is an error, not a miss, and so is a write that fails. Only
+ * `ENOENT` means "nothing is stored". Repairing any of the others silently and
+ * calling HQ anyway would be a second behavior for one failure, and a paid
+ * one; the run names the entry and its cause, and the operator removes it.
+ */
+/** A cache entry that could not be used, or could not be written. */
+declare class JevCacheError extends Error {
+  readonly path: string;
+  constructor(entryPath: string, detail: string);
+}
+/** Where a repository's Jev answers are kept. */
+declare const defaultJevCacheDirectory: (cwd: string) => string;
+interface JevCache {
+  /** The entry key for these request bytes: endpoint plus the bytes, hashed. */
+  keyFor: (serialized: string) => string;
+  /** The stored answer, or `undefined` when nothing is stored. */
+  read: (serialized: string) => JevResponse | undefined;
+  write: (serialized: string, response: JevResponse) => void;
+}
+interface OpenJevCacheInput {
+  /** Defaults to `node_modules/.cache/patronage-jev` under `cwd`. */
+  directory?: string;
+  /** The HQ Jev endpoint these answers came from. Part of every key. */
+  endpoint: string;
+}
+/**
+ * Opens the cache, creating its directory now so a directory that cannot be
+ * written fails here — at the one place that names it — rather than midway
+ * through a run as an unexplained request failure.
+ */
+declare const openJevCache: ({
+  directory,
+  endpoint
+}: OpenJevCacheInput) => JevCache;
+//#endregion
+//#region src/jev/client.d.ts
+/** Sends one prepared packet and returns Jev's body, plus the model HQ ran. */
+type JevEvaluate = (serializedBody: string) => Promise<JevResponse>;
+/**
+ * Either a reachable HQ Jev route, or the one sentence saying why there is
+ * none. A run takes this union rather than a bare `evaluate`, so "there are no
+ * credentials" arrives at the caller in the same shape as "HQ refused": one
+ * typed unavailable result naming its cause, never a throw and never a
+ * silently skipped run.
+ */
+type JevGateway = {
+  evaluate: JevEvaluate;
+  endpoint: string;
+  status: "ready";
+} /** No call is possible. Every match is unavailable with this reason. */ | {
+  reason: string;
+  status: "unavailable";
+};
+/**
+ * An upstream refusal, carried with the code HQ passed through rather than
+ * flattened into prose. `max_tokens_exceeded` is the one a caller acts on: it
+ * means the packet was too large despite the local budget.
+ */
+declare class JevRequestError extends Error {
+  readonly code: string | undefined;
+  readonly httpStatus: number;
+  constructor(httpStatus: number, code: string | undefined, message: string);
+}
+interface ResolveJevGatewayInput {
+  env: NodeJS.ProcessEnv;
+  fetchImpl?: typeof fetch;
+}
+/**
+ * Resolves the gateway, or says why there isn't one. Every `unavailable`
+ * reason is an operator-facing sentence naming a remedy that applies to this
+ * command, and none of them can carry a credential: nothing here reads a
+ * resolved value into a message.
+ *
+ * The order is the policy. The origin is checked against HQ ingest's protocol
+ * rule and the operator's `hqAllowedOrigins` first, and only an authorized
+ * origin gets as far as reading credentials. An unauthorized origin never sees
+ * a request.
+ */
+declare const resolveJevGateway: ({
+  env,
+  fetchImpl
+}: ResolveJevGatewayInput) => Promise<JevGateway>;
+//#endregion
+//#region src/jev/request.d.ts
+interface JevMatch {
+  /**
+   * Stable across splitting. Question names must already namespace it, so
+   * moving a match into a later split never rewrites a question or an answer
+   * name.
+   */
+  key: string;
+  /** Answer-name-keyed questions about this match. */
+  questions: JevQuestions;
+  /** Match-local state, published at `matches.<key>` of the request. */
+  state: JevJsonValue;
+}
+interface JevFile {
+  matches: readonly JevMatch[];
+  /** Repository-relative path. Identity of the shared state, and sent with it. */
+  path: string;
+  /** State every match in this file is read against, sent once per request. */
+  shared: JevJsonValue;
+}
+interface JevRequest {
+  /** The parsed body, for a caller that records a request without sending it. */
+  body: JevRequestBody;
+  estimatedTokens: number;
+  /** SHA-256 of `serialized` — the exact bytes that would be sent. */
+  hash: string;
+  matchKeys: string[];
+  /** The file this request asks about. */
+  path: string;
+  /** The bytes to POST. Serialized once so the hash cannot drift from them. */
+  serialized: string;
+}
+interface JevUnavailableMatch {
+  key: string;
+  reason: string;
+}
+interface JevRequestPlan {
+  requests: JevRequest[];
+  unavailable: JevUnavailableMatch[];
+}
+interface BuildJevRequestsInput {
+  /** Per-request ceiling override, in tokens. Defaults to the budget above. */
+  budgetTokens?: number;
+  files: readonly JevFile[];
+}
+/**
+ * Turns files into the requests that will be sent, plus the matches that
+ * cannot be sent and why. Pure: it performs no I/O and decides nothing about
+ * transport.
+ */
+declare const buildJevRequests: ({
+  budgetTokens,
+  files
+}: BuildJevRequestsInput) => JevRequestPlan;
+//#endregion
+//#region src/jev/run.d.ts
+/**
+ * Sending a file's requests and recording exactly what happened.
+ *
+ * A Jev run is a session diagnostic (ADR 0034): it owns no gate and no demand,
+ * so a failed request is data, not a stop. One request failing never erases
+ * the answers a sibling request already returned, and every match that did not
+ * get an answer says why — including when the failure was that there was no
+ * gateway to call at all.
+ *
+ * Every failure has exactly one behavior: the affected matches become
+ * unavailable, named with their cause. Nothing is retried, nothing is
+ * truncated to fit, and no result is dropped to keep a run tidy.
+ */
+/** What one request did. Recorded whether it succeeded, failed, or was cached. */
+interface JevRequestRecord {
+  /** True when the answer came from the request-hash cache; no HQ call was made. */
+  cached: boolean;
+  elapsedMs: number;
+  /** Set when the request failed; the reason, in operator-facing prose. */
+  error?: string;
+  /** The upstream code, when HQ passed one through (`max_tokens_exceeded`). */
+  errorCode?: string;
+  estimatedTokens: number;
+  matchKeys: string[];
+  /** The model HQ reported actually running. Absent on a failed request. */
+  model?: string;
+  /** The file this request asked about. */
+  path: string;
+  /** SHA-256 of the exact request bytes. */
+  requestHash: string;
+  usage?: JevUsage;
+}
+/** Whether the run got answers for everything it set out to ask about. */
+type JevCompletion = "complete" | "partial" | "unavailable";
+interface JevRunResult {
+  /** Answers per match, keyed by that match's own question names. */
+  answersByMatchKey: Record<string, Record<string, JevAnswer>>;
+  completion: JevCompletion;
+  /** Wall-clock time spent on requests, including cache reads. */
+  elapsedMs: number;
+  /** Distinct models HQ reported, in first-seen order. */
+  models: string[];
+  requests: JevRequestRecord[];
+  /** Why a match has no answers. Every unanswered match appears here. */
+  unavailableByMatchKey: Record<string, string>;
+}
+interface RunJevFilesInput {
+  budgetTokens?: number;
+  /** Omitted means every request is sent live. */
+  cache?: JevCache;
+  files: readonly JevFile[];
+  gateway: JevGateway;
+}
+/**
+ * Builds the requests, sends the ones the cache does not already answer, and
+ * routes answers back to the matches that asked for them.
+ *
+ * Requests go one at a time. Bounded load is the point: a repository-wide run
+ * would otherwise open dozens of concurrent 32k-token requests against one HQ
+ * route for a diagnostic nothing is waiting on.
+ */
+declare const runJevFiles: ({
+  budgetTokens,
+  cache,
+  files,
+  gateway
+}: RunJevFilesInput) => Promise<JevRunResult>;
+//#endregion
 //#region src/index.d.ts
 interface CreateProgramOptions {
   actions?: {
@@ -5356,4 +5626,4 @@ declare function createProgram(options?: CreateProgramOptions): Command;
  */
 declare function run(argv?: string[], cliEntry?: string): Promise<void>;
 //#endregion
-export { type AppendFactoryTraceEventResult, type AssembledReviewPrompt, type BatteryCommandDisposition, type BatteryDisposition, type BoundaryCheckArgs, type BoundaryCheckDependencies, type BoundaryCheckProofRecord, type BuildEpicStructureEventInput, type CloudflareAccessServiceToken, type CompletedFactoryCheckSnapshot, CreateProgramOptions, DEFAULT_DEMAND_WAIVER_PATH, DEFAULT_FACTORY_REPOSITORY, DEFAULT_ROOT_SHARED_GLOBS, type DagDocument, type DemandWaiveArgs, type DemandWaiveDependencies, DemandWaiveRefusalError, type DemandWaiver, type DemandWaiverStore, EMPTY_TREE_OBJECT_HASH, EPIC_STRUCTURE_NODE_STATUSES, EPIC_STRUCTURE_SCHEMA_VERSION, type EpicStructureEvent, type EpicStructureGraphPayload, type EpicStructureNodeStatus, EpicStructureValidationError, type EvidenceEmitArgs, type EvidenceEmitDependencies, type EvidenceEmitResult, FACTORY_BASE_REF_ENV, FACTORY_CHANGED_FILES_ENV, FACTORY_CHANGED_FILES_FILE_ENV, type FactoryCliInvocation, FactoryCliInvocationSchema, type FactoryPrStatusCheckName, type FactoryPrStatusSources, type FactoryProjectProfile, type FactoryTraceDiagnostic, type FactoryTraceEnvelope, type FactoryTraceEvent, type FollowUpAction, FollowUpActionSchema, type GitHubCheckRunMergeFreezeApi, type ImpactScopeDecision, type ImpactScopeSurface, type IssueReviewFocus, MERGE_FREEZE_APP_SLUG, MERGE_FREEZE_CHECK_NAME, type MergeFreezeAuthority, type MergeFreezeGeneration, type MergeFreezeState, type MergeFreezeStoreInput, type PlanFactoryPrStatusHudInput, type PrPublishArgs, type PrPublishDependencies, PrPublishFollowUpError, type PrPublishFollowUpOutcome, type PrPublishHandoff, type PrPublishResult, type PrReadyArgs, type PrReadyProof, type PrVerifyProof, type PresentFactoryPrStatusHudDependencies, type PresentFactoryPrStatusHudInput, type PreviewDisposition, type PreviewLifecyclePlan, type PreviewTargetPlan, type PublishEpicStructureArgs, type PublishEpicStructureResult, type PublishFollowUpPlan, REVIEW_FOCUS_SECTION, type ReadFactoryPrStatusSourcesDependencies, type ReadFactoryPrStatusSourcesInput, type RefreshFactoryPrStatusHudInput, type RenderFactoryPrStatusHudInput, type ReviewGateNotRequiredProof, type ReviewGateTraceIdentity, type ReviewPromptSection, type ReviewPromptSectionProvenance, type ScanFactoryTraceDiagnosticsOptions, type ScanFactoryTraceOptions, type ScanFactoryTraceResult, type ScopedOutCommand, type TraceMirrorDiagnostic, type TraceSink, type TraceWriteResult, type TraceWriteSinks, type VerificationBatteryPlan, type VerificationReuse, type VerificationRunContext, type VerificationRunContextInput, type WaivedDemand, WorkerCheckoutGuardError, type WorkerCloseoutLessonsTraceEvent, appendWithTraceSinks, applyDemandWaiver, assembleReviewPrompt, assertFactoryPrStatusIdentity, assertWorkerCheckoutAllowed, authorizeDemandWaiver, batteryScopeSummaryLines, boundary_manifest_d_exports as boundaryManifest, boundary_review_proof_d_exports as boundaryReviewProof, buildEpicStructureEvent, buildEpicStructurePayload, buildEvidenceEnvelope, buildReviewGateNotRequiredTraceEvent, comment_provenance_d_exports as commentProvenance, createGitHubCheckRunMergeFreezeStore, createLocalJsonlTraceSink, createProgram, createVerificationRunContext, doctorProjectProfile, epicStructureEventId, evidenceEnvelopeFilename, followUpFromArgv, impactStampScopeDecision, isProductionHqUrl, loadProjectProfile, normalizeIssueComments, planFactoryPrStatusHud, planPreviewLifecycle, planPublishFollowUp, planVerificationBattery, readiness_evaluation_d_exports as prReadinessEvaluation, external_evidence_d_exports as prReadinessExternalEvidence, pr_body_renderer_d_exports as prReadinessPrBodyRenderer, proof_identity_d_exports as prReadinessProofIdentity, review_proof_d_exports as prReadinessReviewProof, status_check_rollup_d_exports as prReadinessStatusChecks, verification_proof_d_exports as prReadinessVerificationProof, presentFactoryPrStatusHud, previewLifecycleTargets, publishEpicStructure, readDemandWaivers, readFactoryPrStatusSources, readPrReadyProof, refreshFactoryPrStatusHud, refreshFactoryPrStatusHudSafely, renderFactoryPrStatusHud, resolveFactoryRepository, resolveTraceWriteSinks, reviewFocusFromIssueBody, reviewPromptSectionSchema, reviewPromptSectionsSchema, run, runBoundaryCheck, runDemandWaive, runEvidenceEmit, runPrPublish, runPrReady, runPrReview, runPrVerify, scanFactoryTraceDiagnostics, scanFactoryTraceEvents, selectWaiversForCandidate, toFactoryTraceEnvelope, tryAppendReviewGateNotRequiredTraceEvent, validateBoundaryCheckProof, validateDagDocument, validateDemandWaiverStore, validateFactoryTraceEvent, validateMergeFreezeState, validatePrReadyProof, validatePrVerifyProof, validatePreviewLifecyclePlan, waivedDemandNotice, waivedDemandSchema, worktree_scratch_files_d_exports as worktreeScratchFiles };
+export { type AppendFactoryTraceEventResult, type AssembledReviewPrompt, type BatteryCommandDisposition, type BatteryDisposition, type BoundaryCheckArgs, type BoundaryCheckDependencies, type BoundaryCheckProofRecord, type BuildEpicStructureEventInput, type CloudflareAccessServiceToken, type CompletedFactoryCheckSnapshot, CreateProgramOptions, DEFAULT_DEMAND_WAIVER_PATH, DEFAULT_FACTORY_REPOSITORY, DEFAULT_ROOT_SHARED_GLOBS, type DagDocument, type DemandWaiveArgs, type DemandWaiveDependencies, DemandWaiveRefusalError, type DemandWaiver, type DemandWaiverStore, EMPTY_TREE_OBJECT_HASH, EPIC_STRUCTURE_NODE_STATUSES, EPIC_STRUCTURE_SCHEMA_VERSION, type EpicStructureEvent, type EpicStructureGraphPayload, type EpicStructureNodeStatus, EpicStructureValidationError, type EvidenceEmitArgs, type EvidenceEmitDependencies, type EvidenceEmitResult, FACTORY_BASE_REF_ENV, FACTORY_CHANGED_FILES_ENV, FACTORY_CHANGED_FILES_FILE_ENV, type FactoryCliInvocation, FactoryCliInvocationSchema, type FactoryPrStatusCheckName, type FactoryPrStatusSources, type FactoryProjectProfile, type FactoryTraceDiagnostic, type FactoryTraceEnvelope, type FactoryTraceEvent, type FollowUpAction, FollowUpActionSchema, type GitHubCheckRunMergeFreezeApi, type ImpactScopeDecision, type ImpactScopeSurface, type IssueReviewFocus, type JevAnswer, type JevCache, JevCacheError, type JevCompletion, type JevEvaluate, type JevFile, type JevGateway, type JevJsonValue, type JevMatch, type JevQuestions, type JevRequest, JevRequestError, type JevRequestPlan, type JevRequestRecord, type JevResponse, type JevRunResult, type JevUnavailableMatch, type JevUsage, MERGE_FREEZE_APP_SLUG, MERGE_FREEZE_CHECK_NAME, type MergeFreezeAuthority, type MergeFreezeGeneration, type MergeFreezeState, type MergeFreezeStoreInput, type PlanFactoryPrStatusHudInput, type PrPublishArgs, type PrPublishDependencies, PrPublishFollowUpError, type PrPublishFollowUpOutcome, type PrPublishHandoff, type PrPublishResult, type PrReadyArgs, type PrReadyProof, type PrVerifyProof, type PresentFactoryPrStatusHudDependencies, type PresentFactoryPrStatusHudInput, type PreviewDisposition, type PreviewLifecyclePlan, type PreviewTargetPlan, type PublishEpicStructureArgs, type PublishEpicStructureResult, type PublishFollowUpPlan, REVIEW_FOCUS_SECTION, type ReadFactoryPrStatusSourcesDependencies, type ReadFactoryPrStatusSourcesInput, type RefreshFactoryPrStatusHudInput, type RenderFactoryPrStatusHudInput, type ReviewGateNotRequiredProof, type ReviewGateTraceIdentity, type ReviewPromptSection, type ReviewPromptSectionProvenance, type ScanFactoryTraceDiagnosticsOptions, type ScanFactoryTraceOptions, type ScanFactoryTraceResult, type ScopedOutCommand, type TraceMirrorDiagnostic, type TraceSink, type TraceWriteResult, type TraceWriteSinks, UNKNOWN_MODEL, type VerificationBatteryPlan, type VerificationReuse, type VerificationRunContext, type VerificationRunContextInput, type WaivedDemand, WorkerCheckoutGuardError, type WorkerCloseoutLessonsTraceEvent, appendWithTraceSinks, applyDemandWaiver, assembleReviewPrompt, assertFactoryPrStatusIdentity, assertWorkerCheckoutAllowed, authorizeDemandWaiver, batteryScopeSummaryLines, boundary_manifest_d_exports as boundaryManifest, boundary_review_proof_d_exports as boundaryReviewProof, buildEpicStructureEvent, buildEpicStructurePayload, buildEvidenceEnvelope, buildJevRequests, buildReviewGateNotRequiredTraceEvent, choice, comment_provenance_d_exports as commentProvenance, createGitHubCheckRunMergeFreezeStore, createLocalJsonlTraceSink, createProgram, createVerificationRunContext, defaultJevCacheDirectory, doctorProjectProfile, epicStructureEventId, evidenceEnvelopeFilename, followUpFromArgv, impactStampScopeDecision, isProductionHqUrl, loadProjectProfile, normalizeIssueComments, noul, openJevCache, planFactoryPrStatusHud, planPreviewLifecycle, planPublishFollowUp, planVerificationBattery, readiness_evaluation_d_exports as prReadinessEvaluation, external_evidence_d_exports as prReadinessExternalEvidence, pr_body_renderer_d_exports as prReadinessPrBodyRenderer, proof_identity_d_exports as prReadinessProofIdentity, review_proof_d_exports as prReadinessReviewProof, status_check_rollup_d_exports as prReadinessStatusChecks, verification_proof_d_exports as prReadinessVerificationProof, presentFactoryPrStatusHud, previewLifecycleTargets, publishEpicStructure, readDemandWaivers, readFactoryPrStatusSources, readPrReadyProof, refreshFactoryPrStatusHud, refreshFactoryPrStatusHudSafely, renderFactoryPrStatusHud, resolveFactoryRepository, resolveJevGateway, resolveTraceWriteSinks, reviewFocusFromIssueBody, reviewPromptSectionSchema, reviewPromptSectionsSchema, run, runBoundaryCheck, runDemandWaive, runEvidenceEmit, runJevFiles, runPrPublish, runPrReady, runPrReview, runPrVerify, scanFactoryTraceDiagnostics, scanFactoryTraceEvents, score, selectWaiversForCandidate, toFactoryTraceEnvelope, tryAppendReviewGateNotRequiredTraceEvent, validateBoundaryCheckProof, validateDagDocument, validateDemandWaiverStore, validateFactoryTraceEvent, validateMergeFreezeState, validatePrReadyProof, validatePrVerifyProof, validatePreviewLifecyclePlan, waivedDemandNotice, waivedDemandSchema, worktree_scratch_files_d_exports as worktreeScratchFiles };