@cat-factory/kernel 0.6.0

package/dist/ports/account-repositories.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"account-repositories.js","sourceRoot":"","sources":["../../src/ports/account-repositories.ts"],"names":[],"mappings":""}

package/dist/ports/agent-executor.d.ts

@@ -0,0 +1,361 @@
+import type { AgentConfigValues, AgentKind, BlockType, CloudProvider, ConsensusStepConfig, EnvironmentAccessHandle, EnvironmentStatus, InstanceSize, PullRequestRef, StepSubtasks, TaskEstimate } from '../domain/types.js';
+export interface AgentRunContext {
+    agentKind: AgentKind;
+    pipelineName: string;
+    /**
+     * The workspace and execution the step belongs to. The engine always sets
+     * these; they are optional on the type so existing fakes that hand-build a
+     * context stay valid. Executors that reach beyond the LLM — e.g. the container
+     * executor that clones the workspace's repo and meters spend through a proxy —
+     * require them and fail fast when absent.
+     */
+    workspaceId?: string;
+    executionId?: string;
+    /**
+     * Internal user id (`usr_*`) of whoever started/retried this run. Set by the engine
+     * from the run's `initiatedBy`. The container executor uses it to lease the
+     * initiator's OWN personal (individual-usage) subscription — e.g. Claude — for the
+     * step, since such a credential is never shared. Absent for runs started without a
+     * signed-in user.
+     */
+    initiatedByUserId?: string;
+    /** Index of this step within the pipeline. */
+    stepIndex: number;
+    /** Whether this is the pipeline's last step (drives task finalisation). */
+    isFinalStep: boolean;
+    /**
+     * Consensus configuration for this step, when it is consensus-enabled in the
+     * pipeline (copied from the pipeline's `consensus` array onto the run's step).
+     * Read ONLY by the optional consensus executor (`@cat-factory/consensus`), which
+     * decides — possibly gated on `block.estimate` — whether to run the multi-model
+     * process or delegate to the standard single-actor agent. Absent ⇒ standard agent.
+     */
+    consensus?: ConsensusStepConfig | null;
+    block: {
+        /** Stable block id (set by the engine; used by repo-aware executors). */
+        id?: string;
+        title: string;
+        type: BlockType;
+        description: string;
+        /** Ids of selected best-practice fragments to fold into the system prompt. */
+        fragmentIds?: string[];
+        /**
+         * Fragment bodies the engine pre-resolved from the tenant fragment-library
+         * (the merged catalog + relevance selection; ADR 0006). When present these
+         * are folded into the system prompt verbatim, superseding `fragmentIds`'
+         * static resolution. Absent when the library module is not configured.
+         */
+        resolvedFragments?: {
+            id: string;
+            body: string;
+        }[];
+        /** Id of the model picked for this block (overrides the agent routing), if any. */
+        modelId?: string;
+        /**
+         * Requirements/RFC/PRD pages linked to this block from Confluence, supplied
+         * as extra context. Present only when the Confluence integration is wired and
+         * the block has linked documents.
+         */
+        contextDocs?: {
+            title: string;
+            url: string;
+            excerpt: string;
+        }[];
+        /**
+         * Tracker issues (Jira, …) linked to this block, supplied as extra context.
+         * Present only when the task-source integration is wired and the block has
+         * linked issues. Carries the structured fields so the prompt can render a
+         * status/assignee header alongside the description and recent comments.
+         */
+        contextTasks?: {
+            key: string;
+            url: string;
+            title: string;
+            status: string;
+            type: string;
+            assignee: string | null;
+            priority: string | null;
+            labels: string[];
+            description: string;
+            comments: {
+                author: string;
+                createdAt: string;
+                body: string;
+            }[];
+        }[];
+        /**
+         * Task-level configuration values contributed by the agents in this task's
+         * pipeline (a sparse id→value map; see the agent-config contracts). Folded
+         * into the relevant agents' prompts and job bodies — e.g. the Tester reads
+         * `tester.environment` (local vs ephemeral) and the Playwright agent reads
+         * `playwright.e2eTarget` (ci vs ephemeral). Absent when nothing is set.
+         */
+        agentConfig?: AgentConfigValues;
+        /**
+         * A pull request already opened for this block (e.g. by an earlier `coder`
+         * step in the same run). The Blueprinter step reads its `branch` so it commits
+         * the regenerated blueprint onto the implementation's branch rather than a new
+         * one. Absent until a step records a PR.
+         */
+        pullRequest?: PullRequestRef;
+        /**
+         * The task-estimator's triage of this block (complexity / risk / impact), when
+         * a `task-estimator` step has run earlier in the pipeline. Read by the consensus
+         * executor to gate the (expensive) multi-model process against the step's
+         * configured thresholds. Absent until an estimate has been produced.
+         */
+        estimate?: TaskEstimate | null;
+    };
+    /** Outputs produced by earlier steps in the same run, in order. */
+    priorOutputs: {
+        agentKind: AgentKind;
+        output: string;
+    }[];
+    /** Decisions resolved earlier in this run, for context. */
+    decisions: {
+        question: string;
+        chosen: string;
+    }[];
+    /**
+     * A live ephemeral environment a deployer step provisioned earlier in this run
+     * (resolved from the run's block). Present only when the environment
+     * integration is wired and a deployer step has produced a ready environment —
+     * this is how a downstream tester agent discovers the URL and how to reach it.
+     */
+    environment?: {
+        url: string | null;
+        status: EnvironmentStatus;
+        access: EnvironmentAccessHandle | null;
+        expiresAt: number | null;
+    };
+    /**
+     * Service-level (frame) configuration resolved by the engine from this run's
+     * service frame. Carries what the Tester's local-infra path and the
+     * provisioning layer need: the docker-compose path to stand up dependencies (or
+     * the explicit "no infra" flag), and the cloud provider + abstract instance size
+     * the dispatch resolves to a concrete instance-type id. Absent when no service
+     * frame applies.
+     */
+    service?: {
+        testComposePath?: string;
+        noInfraDependencies?: boolean;
+        cloudProvider?: CloudProvider;
+        instanceSize?: InstanceSize;
+    };
+    /**
+     * If this step previously raised a decision that a human has now resolved,
+     * the resolved decision — so the agent can finish instead of re-raising it.
+     */
+    resolvedDecision: {
+        question: string;
+        chosen: string;
+    } | null;
+    /**
+     * When a human reviewed this step's gated proposal and requested changes, the
+     * previous proposal plus their feedback. Present only on a re-run triggered by
+     * "Request changes"; the agent should revise its previous proposal to address
+     * the feedback rather than start from scratch. `comments` are GitHub-review-style
+     * notes on specific blocks of the proposal (a human review carries the verbatim
+     * `quotedSource` it targets; a companion's anchor-based comment omits it), folded
+     * into the prompt alongside the freeform `feedback`.
+     */
+    revision?: {
+        previousProposal: string;
+        feedback: string;
+        comments?: {
+            quotedSource?: string;
+            body: string;
+        }[];
+    };
+}
+/** A point at which the agent needs a human to choose before continuing. */
+export interface AgentDecisionRequest {
+    question: string;
+    options: string[];
+}
+/** Token usage reported by the model for a single agent call. */
+export interface AgentTokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+}
+export interface AgentRunResult {
+    /** The agent's work product. Required unless `decision` is set. */
+    output?: string;
+    /** Identifier of the model that produced the output, for transparency. */
+    model?: string;
+    /** Ask a human to decide before this step can complete. */
+    decision?: AgentDecisionRequest;
+    /** Confidence in the result (0..1); used at task completion to auto-merge. */
+    confidence?: number;
+    /**
+     * A pull request the agent opened for its work. Reported by repo-operating
+     * executors (the container "implementer" agent, which pushes a branch and opens
+     * a PR); the engine records it on the block so the board can link to it.
+     */
+    pullRequest?: PullRequestRef;
+    /**
+     * The service → modules blueprint tree a Blueprinter step produced.
+     * The engine strictly validates it and reconciles it onto the board (in place).
+     * Carried as `unknown` so the core port stays free of the contracts schema; the
+     * engine parses it with the authoritative Valibot schema before use.
+     */
+    blueprintService?: unknown;
+    /**
+     * The unified, prescriptive specification doc a `spec-writer` step produced and
+     * committed to the implementation branch (the `spec.json` tree). The engine
+     * strictly validates it (against the contracts schema) and may surface it on the
+     * board. Carried as `unknown` so the core port stays free of the contracts schema;
+     * the engine parses it before use.
+     */
+    spec?: unknown;
+    /**
+     * A `merger` step's structured PR assessment (complexity / risk / impact +
+     * rationale). The engine validates it, compares the scores against the task's
+     * resolved merge preset, and either performs a real GitHub merge or raises a
+     * `merge_review` notification. Carried as `unknown` so the port stays free of
+     * the contracts schema; the engine parses it before use.
+     */
+    mergeAssessment?: unknown;
+    /**
+     * A `tester` step's structured test report (what was exercised, the per-area
+     * outcomes, any concerns/bugs, and the greenlight verdict). The engine validates
+     * it and, when the Tester withholds its greenlight, dispatches the `fixer` agent
+     * and re-tests — looping until greenlight or the attempt budget is spent. Carried
+     * as `unknown` so the port stays free of the contracts schema; the engine parses
+     * it before use.
+     */
+    testReport?: unknown;
+    /**
+     * An `on-call` step's structured release-regression assessment (culprit confidence,
+     * recommendation, rationale, evidence). The post-release-health gate dispatched the
+     * agent on a Datadog regression; the engine validates this, raises a
+     * `release_regression` notification and enriches any open incident. Carried as
+     * `unknown` so the port stays free of the contracts schema; the engine parses it.
+     */
+    onCallAssessment?: unknown;
+    /**
+     * Tokens the model consumed for this call. Reported by inline LLM executors so
+     * the spend safeguard can meter usage; absent for the container executor (whose
+     * proxy meters tokens itself, to avoid double-counting) and test fakes.
+     */
+    usage?: AgentTokenUsage;
+}
+export interface AgentExecutor {
+    run(context: AgentRunContext): Promise<AgentRunResult>;
+    /**
+     * Resolve the concrete model this step will run (`provider:model`) WITHOUT doing
+     * the work — no LLM call, no container dispatch. The engine calls it up front so a
+     * step's model can be surfaced to the board the moment the step starts (during the
+     * inline LLM query, or the container cold-boot window) rather than only once the
+     * result/job handle lands. Must be cheap and side-effect-free (model-ref resolution
+     * only). Optional: an executor that can't cheaply preview omits it, and the engine
+     * simply records the model later. Returns undefined when no model applies.
+     */
+    resolveModel?(context: AgentRunContext): Promise<string | undefined>;
+    /**
+     * Whether this step will run on a flat-rate subscription (quota) model — i.e. a
+     * Claude Code / Codex harness authenticated with a pooled subscription token. Such
+     * runs incur NO metered monetary LLM cost (their usage is folded into a quota, not
+     * the spend budget), so the engine's spend gate lets them proceed even when the
+     * monetary budget is exhausted. Must be cheap and side-effect-free (model-ref
+     * resolution only). Optional: an executor without subscription harnesses omits it
+     * and the engine treats every step as budget-metered (the prior behaviour).
+     */
+    isQuotaBased?(context: AgentRunContext): Promise<boolean>;
+}
+/** A handle to an asynchronous agent job (e.g. a long-running container run). */
+export interface AgentJobHandle {
+    /** Opaque identifier the executor uses to address the running job when polled. */
+    jobId: string;
+    /**
+     * The run (execution) the job belongs to. A run executes a sequence of jobs (one
+     * per pipeline step) that share one per-run container, so the poll/stop site needs
+     * the run id — alongside the per-step {@link jobId} — to address that container
+     * (and to reclaim it). Set by the executor at dispatch and re-supplied by the
+     * engine at the poll/stop site (it always has the execution id in scope). Absent ⇒
+     * the job IS its own run (a single-job flow), so callers fall back to {@link jobId}.
+     */
+    runId?: string;
+    /**
+     * The model the job runs (`provider:model`), known at dispatch. Recorded on the
+     * step immediately so the board shows it even though the poll site — which maps
+     * the eventual result — has no access to the resolved model ref.
+     */
+    model?: string;
+    /**
+     * The workspace the job belongs to. The engine sets this at the poll site (it is
+     * in scope there) so an executor that picks a per-workspace backend — e.g. the
+     * container executor choosing a self-hosted runner pool over Cloudflare
+     * Containers — can resolve the same backend when polling, given only the job id.
+     */
+    workspaceId?: string;
+    /**
+     * For a subscription-harness job, the id of the pooled token leased for it, so
+     * the poll site can attribute the run's usage back to the right pool row
+     * (usage-aware rotation). Absent for proxy-metered Pi jobs.
+     */
+    subscriptionTokenId?: string;
+    /**
+     * The agent kind the job runs as (`coder`, `merger`, …). Carried so the poll site
+     * can label the job's tool spans when forwarding them to the observability trace
+     * sink. Optional — absent ⇒ spans are still grouped under the run, just unlabelled.
+     */
+    agentKind?: string;
+}
+/** The outcome of polling an {@link AgentJobHandle}. */
+export type AgentJobUpdate = 
+/**
+ * Still working — the durable driver should keep polling. `subtasks`, when
+ * present, carries the job's latest subtask counts (the container agent reads
+ * these from the coding tool's todo list) so the driver can surface live
+ * "N/M done" progress on the step between polls.
+ */
+{
+    state: 'running';
+    subtasks?: StepSubtasks;
+}
+/** Finished successfully; `result` carries the work product. */
+ | {
+    state: 'done';
+    result: AgentRunResult;
+}
+/** Finished with a failure (agent error, inactivity/max-duration watchdog, …). */
+ | {
+    state: 'failed';
+    error: string;
+};
+/**
+ * An executor whose work can outlive a single request. Instead of `run()`
+ * blocking until the work finishes — which would cap the work at one durable
+ * step's timeout — the driver {@link startJob}s it and then {@link pollJob}s for
+ * completion between durable sleeps. This lets a long coding job run for many
+ * minutes while every individual driver step stays short and cheaply retriable.
+ *
+ * Implemented by the container executor (whose Pi coding run can take a long
+ * time); inline LLM executors stay plain {@link AgentExecutor}s and run in one
+ * shot. `run()` remains available (it dispatches then polls internally) for
+ * non-durable callers and tests.
+ */
+export interface AsyncAgentExecutor extends AgentExecutor {
+    /** Whether `context` should be driven as a polled job rather than run inline. */
+    runsAsync(context: AgentRunContext): boolean;
+    /**
+     * Start the job for `context`, or re-attach to one already running for it. Must
+     * be idempotent per execution so a replayed dispatch never starts a duplicate.
+     */
+    startJob(context: AgentRunContext): Promise<AgentJobHandle>;
+    /** Poll a previously-started job for its current state. */
+    pollJob(handle: AgentJobHandle): Promise<AgentJobUpdate>;
+    /**
+     * Best-effort: stop a running job and reclaim its backing resources (e.g. kill
+     * the per-run container), so a user cancel / block delete / orphan sweep does not
+     * leak a container that idles until its watchdog. Optional — backends with
+     * nothing to reclaim may omit it; callers must treat it as best-effort and must
+     * not let a failure here derail their own teardown. Idempotent: stopping an
+     * already-gone job is a no-op.
+     */
+    stopJob?(handle: AgentJobHandle): Promise<void>;
+}
+/** Narrow an executor to the async-capable interface. */
+export declare function isAsyncAgentExecutor(executor: AgentExecutor): executor is AsyncAgentExecutor;
+//# sourceMappingURL=agent-executor.d.ts.map

package/dist/ports/agent-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-executor.d.ts","sourceRoot":"","sources":["../../src/ports/agent-executor.ts"],"names":[],"mappings":"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"}

package/dist/ports/agent-executor.js

@@ -0,0 +1,8 @@
+/** Narrow an executor to the async-capable interface. */
+export function isAsyncAgentExecutor(executor) {
+    const candidate = executor;
+    return (typeof candidate.runsAsync === 'function' &&
+        typeof candidate.startJob === 'function' &&
+        typeof candidate.pollJob === 'function');
+}
+//# sourceMappingURL=agent-executor.js.map

package/dist/ports/agent-executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-executor.js","sourceRoot":"","sources":["../../src/ports/agent-executor.ts"],"names":[],"mappings":"AAoWA,yDAAyD;AACzD,MAAM,UAAU,oBAAoB,CAAC,QAAuB;IAC1D,MAAM,SAAS,GAAG,QAAuC,CAAA;IACzD,OAAO,CACL,OAAO,SAAS,CAAC,SAAS,KAAK,UAAU;QACzC,OAAO,SAAS,CAAC,QAAQ,KAAK,UAAU;QACxC,OAAO,SAAS,CAAC,OAAO,KAAK,UAAU,CACxC,CAAA;AACH,CAAC"}

package/dist/ports/agent-runs.d.ts

@@ -0,0 +1,28 @@
+import type { AgentRunKind } from '../domain/types.js';
+/**
+ * A lightweight, kind-tagged reference to an entry in the unified `agent_runs`
+ * table. Used by cross-kind machinery — the cron sweeper (re-drive any stale run
+ * via the right durable workflow) and the unified retry endpoint (dispatch to the
+ * right service) — without coupling them to either flow's full record shape.
+ */
+export interface AgentRunRef {
+    workspaceId: string;
+    id: string;
+    kind: AgentRunKind;
+}
+/**
+ * Read-only, kind-spanning view over `agent_runs`. The per-flow repositories
+ * ({@link ExecutionRepository}, BootstrapJobRepository) own writes scoped to their
+ * own kind; this port answers the two questions that span both kinds.
+ */
+export interface AgentRunRepository {
+    /** The kind of a run (to dispatch a retry), or null if no such run exists. */
+    getRef(workspaceId: string, id: string): Promise<AgentRunRef | null>;
+    /**
+     * Runs of any kind still marked `running` whose lease (`updated_at`) is older
+     * than the given epoch-ms cutoff — candidates the durable driver may have
+     * dropped. Spans all workspaces so a single cron pass repairs the whole system.
+     */
+    listStale(olderThanEpochMs: number): Promise<AgentRunRef[]>;
+}
+//# sourceMappingURL=agent-runs.d.ts.map

package/dist/ports/agent-runs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-runs.d.ts","sourceRoot":"","sources":["../../src/ports/agent-runs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEtD;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,WAAW,EAAE,MAAM,CAAA;IACnB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,YAAY,CAAA;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,8EAA8E;IAC9E,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;IACpE;;;;OAIG;IACH,SAAS,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAAA;CAC5D"}

package/dist/ports/agent-runs.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=agent-runs.js.map

package/dist/ports/agent-runs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-runs.js","sourceRoot":"","sources":["../../src/ports/agent-runs.ts"],"names":[],"mappings":""}

package/dist/ports/board-operations.d.ts

@@ -0,0 +1,15 @@
+import type { AddFrameInput, AddModuleInput, AddTaskInput, UpdateBlockInput } from '@cat-factory/contracts';
+import type { Block } from '../domain/types.js';
+/**
+ * The write-side board operations needed by integration packages (e.g.
+ * DocumentLinkService) that materialise external structure onto the board.
+ * A narrow port so the integrations package does not depend on the full
+ * BoardService class.
+ */
+export interface BoardWritePort {
+    addFrame(workspaceId: string, input: AddFrameInput): Promise<Block>;
+    addModule(workspaceId: string, frameId: string, input: AddModuleInput): Promise<Block>;
+    addTask(workspaceId: string, containerId: string, input: AddTaskInput, createdBy?: string | null): Promise<Block>;
+    updateBlock(workspaceId: string, blockId: string, patch: UpdateBlockInput): Promise<Block>;
+}
+//# sourceMappingURL=board-operations.d.ts.map

package/dist/ports/board-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"board-operations.d.ts","sourceRoot":"","sources":["../../src/ports/board-operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,YAAY,EACZ,gBAAgB,EACjB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAE/C;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,KAAK,CAAC,CAAA;IACnE,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,KAAK,CAAC,CAAA;IACtF,OAAO,CACL,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,YAAY,EACnB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GACxB,OAAO,CAAC,KAAK,CAAC,CAAA;IACjB,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAAA;CAC3F"}

package/dist/ports/board-operations.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=board-operations.js.map

package/dist/ports/board-operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"board-operations.js","sourceRoot":"","sources":["../../src/ports/board-operations.ts"],"names":[],"mappings":""}

package/dist/ports/board-scan-repositories.d.ts

@@ -0,0 +1,23 @@
+import type { BlueprintService, BlueprintSource } from '../domain/types.js';
+/** A persisted repository blueprint (the decomposition tree, projected locally). */
+export interface RepoBlueprintRecord {
+    id: string;
+    workspaceId: string;
+    repoOwner: string;
+    repoName: string;
+    source: BlueprintSource;
+    /** The service → modules tree. */
+    service: BlueprintService;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface RepoBlueprintRepository {
+    /** Insert or replace the blueprint for this (workspace, repo). */
+    upsert(record: RepoBlueprintRecord): Promise<void>;
+    get(workspaceId: string, id: string): Promise<RepoBlueprintRecord | null>;
+    /** The current blueprint for a repo, if one has been scanned. */
+    getByRepo(workspaceId: string, repoOwner: string, repoName: string): Promise<RepoBlueprintRecord | null>;
+    listByWorkspace(workspaceId: string): Promise<RepoBlueprintRecord[]>;
+    delete(workspaceId: string, id: string): Promise<void>;
+}
+//# sourceMappingURL=board-scan-repositories.d.ts.map

package/dist/ports/board-scan-repositories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"board-scan-repositories.d.ts","sourceRoot":"","sources":["../../src/ports/board-scan-repositories.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAQ3E,oFAAoF;AACpF,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAA;IACV,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,eAAe,CAAA;IACvB,kCAAkC;IAClC,OAAO,EAAE,gBAAgB,CAAA;IACzB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,uBAAuB;IACtC,kEAAkE;IAClE,MAAM,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAClD,GAAG,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAAA;IACzE,iEAAiE;IACjE,SAAS,CACP,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAAA;IACtC,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAAA;IACpE,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACvD"}

package/dist/ports/board-scan-repositories.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=board-scan-repositories.js.map

package/dist/ports/board-scan-repositories.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"board-scan-repositories.js","sourceRoot":"","sources":["../../src/ports/board-scan-repositories.ts"],"names":[],"mappings":""}

package/dist/ports/bootstrap-repositories.d.ts

@@ -0,0 +1,71 @@
+import type { BootstrapFailure, BootstrapStatus, StepSubtasks } from '../domain/types.js';
+/**
+ * A managed reference architecture: a base repo new repositories are
+ * bootstrapped from, plus default bootstrapper instructions.
+ */
+export interface ReferenceArchitectureRecord {
+    id: string;
+    workspaceId: string;
+    name: string;
+    description: string;
+    repoOwner: string;
+    repoName: string;
+    defaultInstructions: string;
+    createdAt: number;
+    updatedAt: number;
+    /** Set when the entry is removed (tombstone). */
+    deletedAt: number | null;
+}
+export type ReferenceArchitectureRecordPatch = Partial<Pick<ReferenceArchitectureRecord, 'name' | 'description' | 'repoOwner' | 'repoName' | 'defaultInstructions' | 'updatedAt'>>;
+export interface ReferenceArchitectureRepository {
+    insert(record: ReferenceArchitectureRecord): Promise<void>;
+    update(workspaceId: string, id: string, patch: ReferenceArchitectureRecordPatch): Promise<void>;
+    get(workspaceId: string, id: string): Promise<ReferenceArchitectureRecord | null>;
+    listByWorkspace(workspaceId: string): Promise<ReferenceArchitectureRecord[]>;
+    softDelete(workspaceId: string, id: string, at: number): Promise<void>;
+}
+/** One "bootstrap repo" run and its outcome, projected locally. */
+export interface BootstrapJobRecord {
+    id: string;
+    workspaceId: string;
+    /** Reference architecture the run was based on, or null for a from-scratch run. */
+    referenceArchitectureId: string | null;
+    /** Denormalized reference architecture name, or null for a from-scratch run. */
+    referenceArchitectureName: string | null;
+    repoName: string;
+    repoOwner: string | null;
+    repoUrl: string | null;
+    instructions: string;
+    status: BootstrapStatus;
+    /** The board service frame this run materialises, or null if none was created. */
+    blockId: string | null;
+    /** Live subtask counts from the bootstrapper agent, or null until it reports. */
+    subtasks: StepSubtasks | null;
+    error: string | null;
+    /** Structured failure diagnostics when `status` is `failed`; null otherwise. */
+    failure: BootstrapFailure | null;
+    createdAt: number;
+    updatedAt: number;
+}
+export type BootstrapJobRecordPatch = Partial<Pick<BootstrapJobRecord, 'status' | 'repoOwner' | 'repoUrl' | 'blockId' | 'subtasks' | 'error' | 'failure' | 'updatedAt'>>;
+export interface BootstrapJobRepository {
+    insert(record: BootstrapJobRecord): Promise<void>;
+    update(workspaceId: string, id: string, patch: BootstrapJobRecordPatch): Promise<void>;
+    get(workspaceId: string, id: string): Promise<BootstrapJobRecord | null>;
+    listByWorkspace(workspaceId: string): Promise<BootstrapJobRecord[]>;
+    /**
+     * Every bootstrap run belonging to a service, regardless of which workspace ran it. Backs the
+     * board snapshot for a service mounted from another workspace in the same org, so a shared
+     * service's in-flight bootstrap renders on every board that mounts it. Matches the
+     * `service_id` column stamped from the run's service frame.
+     */
+    listByService(serviceId: string): Promise<BootstrapJobRecord[]>;
+    /**
+     * Every bootstrap run belonging to ANY of the given services, in a single (chunked) query —
+     * the batched form of {@link BootstrapJobRepository.listByService} used to compose a board's
+     * bootstrap runs from all the services it mounts without one round-trip per mount. Empty
+     * input → empty.
+     */
+    listByServices(serviceIds: string[]): Promise<BootstrapJobRecord[]>;
+}
+//# sourceMappingURL=bootstrap-repositories.d.ts.map

package/dist/ports/bootstrap-repositories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap-repositories.d.ts","sourceRoot":"","sources":["../../src/ports/bootstrap-repositories.ts"],"names":[],"mappings":"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"}

package/dist/ports/bootstrap-repositories.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bootstrap-repositories.js.map

package/dist/ports/bootstrap-repositories.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap-repositories.js","sourceRoot":"","sources":["../../src/ports/bootstrap-repositories.ts"],"names":[],"mappings":""}

package/dist/ports/bootstrap-runner.d.ts

@@ -0,0 +1,20 @@
+export interface BootstrapRunner {
+    /**
+     * Begin durably driving the bootstrap job `jobId` for `workspaceId`. Must be
+     * idempotent per job id (a duplicate start, or a sweeper re-drive racing a live
+     * instance, is a no-op) — the persisted job record is authoritative.
+     */
+    startRun(workspaceId: string, jobId: string): Promise<void>;
+    /**
+     * Best-effort: tear down the durable driver for `jobId` (terminate its Workflows
+     * instance) when the run is being stopped/cancelled. Idempotent — no live
+     * instance to terminate is a no-op.
+     */
+    cancelRun(workspaceId: string, jobId: string): Promise<void>;
+}
+/** The default runner: does nothing (tests drive `pollBootstrapJob` directly). */
+export declare class NoopBootstrapRunner implements BootstrapRunner {
+    startRun(): Promise<void>;
+    cancelRun(): Promise<void>;
+}
+//# sourceMappingURL=bootstrap-runner.d.ts.map

package/dist/ports/bootstrap-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap-runner.d.ts","sourceRoot":"","sources":["../../src/ports/bootstrap-runner.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC3D;;;;OAIG;IACH,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC7D;AAED,kFAAkF;AAClF,qBAAa,mBAAoB,YAAW,eAAe;IACnD,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAG;IAC5B,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAAG;CACpC"}

package/dist/ports/bootstrap-runner.js

@@ -0,0 +1,12 @@
+// Port for durably driving a "bootstrap repo" run's poll loop, mirroring
+// WorkRunner for pipeline runs. After BootstrapService dispatches the container it
+// asks the runner to start driving: the worker maps each run to one Cloudflare
+// Workflows instance (the BootstrapWorkflow) that polls until the run reaches a
+// terminal state, updating subtasks and finalising the board frame. Tests leave it
+// unset and drive `pollBootstrapJob` directly, exactly as the execution tests do.
+/** The default runner: does nothing (tests drive `pollBootstrapJob` directly). */
+export class NoopBootstrapRunner {
+    async startRun() { }
+    async cancelRun() { }
+}
+//# sourceMappingURL=bootstrap-runner.js.map

package/dist/ports/bootstrap-runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap-runner.js","sourceRoot":"","sources":["../../src/ports/bootstrap-runner.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,mFAAmF;AACnF,+EAA+E;AAC/E,gFAAgF;AAChF,mFAAmF;AACnF,kFAAkF;AAiBlF,kFAAkF;AAClF,MAAM,OAAO,mBAAmB;IAC9B,KAAK,CAAC,QAAQ,KAAmB,CAAC;IAClC,KAAK,CAAC,SAAS,KAAmB,CAAC;CACpC"}

package/dist/ports/ci-status.d.ts

@@ -0,0 +1,23 @@
+/** One CI check for the head commit, flattened from the GitHub check-run shape. */
+export interface CiCheck {
+    name: string;
+    /** GitHub check status: 'queued' | 'in_progress' | 'completed'. */
+    status: string;
+    /** GitHub conclusion when completed: 'success' | 'failure' | 'neutral' | … (null while running). */
+    conclusion: string | null;
+}
+export interface CiStatusReport {
+    /** The PR head commit whose checks these are; null when no PR/branch resolved. */
+    headSha: string | null;
+    /** The check runs reported for `headSha` (empty when none are configured/registered yet). */
+    checks: CiCheck[];
+}
+export interface CiStatusProvider {
+    /**
+     * Resolve the head commit of the block's open PR and list its CI check runs.
+     * Returns `{ headSha: null, checks: [] }` when the block has no resolvable PR
+     * branch yet (the engine treats this as "nothing to gate").
+     */
+    getStatus(workspaceId: string, blockId: string): Promise<CiStatusReport>;
+}
+//# sourceMappingURL=ci-status.d.ts.map