@fabrika/builder 0.8.1 → 0.9.0-cloudflare.1

package/daemon/src/platform-remote.ts

@@ -1,5 +1,6 @@
 import { createRpcClient, type RpcFetch } from '@fabrika/app'
 import {
+	APP_ENV_KINDS,
 	type AppEnvDto,
 	type ControlRpcContract,
 	type JsonValue,
@@ -46,6 +47,8 @@ const environmentsSchema = z.object({
 	items: z.array(z.object({
 		appId: storedTextSchema,
 		env: storedTextSchema,
+		// A Control older than the field has standard environments only.
+		kind: z.enum(APP_ENV_KINDS).default('standard'),
 		domain: storedTextSchema.nullable(),
 		publicOrigin: storedTextSchema.nullable(),
 		// A Control older than the field lists none.

package/decisions/technologies/zerops-fabrika-auth.md

@@ -7,7 +7,7 @@ provides: [authentication, authorization, proxy-enforcement]
 requires: [zerops-platform]
 recommends: []
 conflicts: [propustka, cloudflare-access, auth-password-kv]
-npm: ["@fabrika/app@0.8.1", "@fabrika/db@0.8.1", "zod@^3.25.76"]
+npm: ["@fabrika/app@0.9.0-cloudflare.1", "@fabrika/db@0.9.0-cloudflare.1", "zod@^3.25.76"]
 status: wip
 sources:
   - where: "packages/app/skill/SKILL.md in fabrika-platform (the `fabrika-app` skill)"

package/decisions/technologies/zerops-platform.md

@@ -7,7 +7,7 @@ provides: [platform, private-services, managed-deploy]
 requires: [bun, postgres]
 recommends: []
 conflicts: [cloudflare]
-npm: ["@fabrika/provider-zerops@0.8.1", "@fabrika/app@0.8.1", "@fabrika/cli@0.8.1"]
+npm: ["@fabrika/provider-zerops@0.9.0-cloudflare.1", "@fabrika/app@0.9.0-cloudflare.1", "@fabrika/cli@0.9.0-cloudflare.1"]
 status: wip
 sources:
   - where: "examples/zerops-app/fabrika.config.ts + zerops.yaml in fabrika-platform"
@@ -43,12 +43,13 @@ truth: stable `id`, `schema`, `pipeline` and `target` with `platform: 'zerops'`.
   `zerops.yaml` keeps only `setup`, `build.base`, `build.os` and the SPA's
   `build.buildCommands`; every other key is refused. The platform generates the
   rest: a frozen install, the application's `bun test`, a reinstall, the
-  generated entrypoint, `fabrika-check`, `tsc`, the deploy gate on the contract's
+  generated entrypoint, `tsc` (with `web/`), `fabrika-check`, the deploy gate on the contract's
   health path, and the `run` section. Its init commands run `fabrika db migrate`,
   `fabrika db codegen --verify` and `fabrika db test-isolation`, then its
   start script runs `fabrika/entry.generated.ts`; each `c.cron` job becomes a crontab entry
   `fabrika job run <name>`. The build has no database, so the database tests skip
-  there and run at container start.
+  there; only the generated isolation tests run again, at container start. Run
+  the rest against a test database before you push.
 - Commit the Bun lockfile at the app repository root, and commit what
   `fabrika db codegen` and `fabrika db test-scaffold` write. Never edit a
   generated file (`fabrika/entry.generated.ts`, `src/db/schema.generated.ts`, the

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@fabrika/builder",
-	"version": "0.8.1",
+	"version": "0.9.0-cloudflare.1",
 	"type": "module",
 	"description": "Local-first guided application design and agent-assisted implementation.",
 	"license": "MIT",
@@ -25,17 +25,18 @@
 		"stacks",
 		"README.md",
 		"BUILD-CONTRACT.md",
-		"LICENSE"
+		"LICENSE",
+		"types"
 	],
 	"exports": {
 		".": {
 			"bun": "./index.ts",
-			"types": "./index.ts",
+			"types": "./types/index.d.ts",
 			"default": "./index.ts"
 		},
 		"./daemon": {
 			"bun": "./daemon/src/index.ts",
-			"types": "./daemon/src/index.ts",
+			"types": "./types/daemon/src/index.d.ts",
 			"default": "./daemon/src/index.ts"
 		}
 	},
@@ -47,13 +48,13 @@
 	},
 	"dependencies": {
 		"zod": "^3.25.76",
-		"@fabrika/annotations": "0.8.1",
-		"@fabrika/app": "0.8.1",
-		"@fabrika/auth-core": "0.8.1",
-		"@fabrika/canvas-kernel": "0.8.1",
-		"@fabrika/control-contract": "0.8.1",
-		"@fabrika/daemon-kit": "0.8.1",
-		"@fabrika/provider-zerops": "0.8.1",
+		"@fabrika/annotations": "0.9.0-cloudflare.1",
+		"@fabrika/app": "0.9.0-cloudflare.1",
+		"@fabrika/auth-core": "0.9.0-cloudflare.1",
+		"@fabrika/canvas-kernel": "0.9.0-cloudflare.1",
+		"@fabrika/control-contract": "0.9.0-cloudflare.1",
+		"@fabrika/daemon-kit": "0.9.0-cloudflare.1",
+		"@fabrika/provider-zerops": "0.9.0-cloudflare.1",
 		"preact": "^10.25.0"
 	}
 }

package/types/cli/src/bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export declare const BUILDER_USAGE = "fabrika builder \u2014 guided application builder\n\nUsage:\n  fabrika builder init [dir] [--profile <stack>] [--agent all|claude|codex]\n                       [--session=<id>] [--no-open] [--no-daemon] [--json]\n                                               Scaffold .fabrika/, install agent support, open dashboard\n  fabrika builder next [--json]                      Print the task packet for the current derived phase\n  fabrika builder init [dir] --url=<origin> [--no-open]  Initialize zerops-app and begin human consent\n                         [--no-daemon]               Offline init only; incompatible with --url\n  fabrika builder connect --url=<origin> [--no-open] [--json]\n  fabrika builder status [--json]                    Read connection and deployment status\n  fabrika builder disconnect [--json]                Remove local custody; revoke separately in console\n  fabrika builder deploy [--wait] [--timeout=<seconds>] [--json]\n  fabrika builder preview --url=<url> | --clear [--json]\n                                                    Platform commands also accept --dir=<project>\n                                                    Results are sanitized JSON; wait defaults to 600 seconds\n                                                    --no-open returns the local dashboard URL, never approval proof\n                                                    All commands accept --help and never prompt for input\n  fabrika builder advance [--force]                  Validate outputs and gate, then print the next phase\n  fabrika builder gate open <name> --view <f.jsx>    Push a canvas gate and open the dashboard\n  fabrika builder gate wait [--gate <n>] [--timeout] Wait for submitted gate feedback\n  fabrika builder ensure-daemon                      Start the daemon if it is not running\n  fabrika builder induce [--force]                   Derive issues from opice skeleton metadata\n  fabrika builder build [--issue <ID>] [--assisted]  Run the assisted per-issue build driver\n\nEnvironment:\n  FABRIKA_PORT         Daemon port (default 19410)\n  FABRIKA_SESSION_ID   Session id (fallback: stable hash of repo abs path)\n  FABRIKA_DATA_DIR     Persistent daemon/session data (default ~/.fabrika)\n  FABRIKA_TIMEOUT      gate wait timeout in ms (default 3600000)";
+export declare function runBuilderCli(argv: readonly string[]): Promise<number>;

package/types/cli/src/build-status.d.ts

@@ -0,0 +1,20 @@
+import type { Issue } from './issues';
+export type IssueStatus = 'done' | 'blocked';
+export interface BuildRecord {
+    status: IssueStatus;
+    reason?: string;
+    at: string;
+}
+export type BuildBoard = Record<string, BuildRecord>;
+export declare function readBoard(fabrikaDir: string): BuildBoard;
+export declare function writeBoard(fabrikaDir: string, board: BuildBoard): void;
+export declare function record(fabrikaDir: string, id: string, status: IssueStatus, reason: string | undefined, at: string): BuildBoard;
+export interface BuildPlan {
+    done: Issue[];
+    blocked: Issue[];
+    ready: Issue[];
+    waiting: Issue[];
+    next: Issue | null;
+    complete: boolean;
+}
+export declare function planBuild(issues: Issue[], board: BuildBoard): BuildPlan;

package/types/cli/src/catalog.d.ts

@@ -0,0 +1,9 @@
+export declare function resolveCatalogRoot(): string | null;
+export interface StackPointer {
+    profile: string;
+    root: string;
+    stackFile: string;
+    stackFileExists: boolean;
+    decisionsDir: string;
+}
+export declare function resolveStackPointer(profile: string): StackPointer | null;

package/types/cli/src/commands/advance.d.ts

@@ -0,0 +1 @@
+export declare function cmdAdvance(argv: string[]): Promise<number>;

package/types/cli/src/commands/build.d.ts

@@ -0,0 +1 @@
+export declare function cmdBuild(argv: string[]): Promise<number>;

package/types/cli/src/commands/ensure-daemon.d.ts

@@ -0,0 +1 @@
+export declare function cmdEnsureDaemon(_argv: string[]): Promise<number>;

package/types/cli/src/commands/gate.d.ts

@@ -0,0 +1 @@
+export declare function cmdGate(argv: string[]): Promise<number>;

package/types/cli/src/commands/induce.d.ts

@@ -0,0 +1 @@
+export declare function cmdInduce(argv: string[]): Promise<number>;

package/types/cli/src/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function cmdInit(argv: string[]): Promise<number>;

package/types/cli/src/commands/next.d.ts

@@ -0,0 +1 @@
+export declare function cmdNext(argv: string[]): Promise<number>;

package/types/cli/src/commands/platform.d.ts

@@ -0,0 +1,2 @@
+export type PlatformCommand = 'connect' | 'status' | 'disconnect' | 'deploy' | 'preview';
+export declare function cmdPlatform(command: PlatformCommand, argv: string[]): Promise<number>;

package/types/cli/src/config.d.ts

@@ -0,0 +1,16 @@
+export declare const DAEMON_PORT: number;
+export declare const BASE_URL: string;
+export declare const WS_URL: string;
+export declare const TIMEOUT_MS: number;
+export declare const NEUTRAL_DATA_DIR: string;
+export declare const DATA_DIR: string;
+export declare const SESSIONS_DIR: string;
+export declare const TEMP_DIR: string;
+export declare const PID_FILE: string;
+export declare const FABRIKA_DIRNAME = ".fabrika";
+export declare function resolveDataDir(opts?: {
+    home?: string;
+    explicit?: string;
+}): string;
+export declare function getSessionId(explicit?: string, recorded?: string, repoRoot?: string): string;
+export declare function hashRepoPath(repoRoot: string): string;

package/types/cli/src/context.d.ts

@@ -0,0 +1,13 @@
+import type { BuilderProjectConnection } from '../../shared';
+export interface CommandContext {
+    repoRoot: string;
+    fabrikaDir: string;
+    sessionId: string;
+    profile: string;
+    initialized: boolean;
+    connection?: BuilderProjectConnection;
+}
+export declare function resolveContext(opts?: {
+    dir?: string;
+    session?: string;
+}): CommandContext;

package/types/cli/src/daemon-client.d.ts

@@ -0,0 +1,36 @@
+import type { PhaseState } from './derive';
+export declare function fetchPhase(fabrikaDir: string, sessionId?: string): Promise<PhaseState | null>;
+export interface PlanResult {
+    ok: boolean;
+    browserUrl?: string;
+    revision?: number;
+    isNew?: boolean;
+    canvasFiles?: string[];
+    gate?: string;
+    error?: string;
+    errors?: Record<string, string>;
+}
+export type PlanSource = {
+    view: string;
+    directory?: never;
+} | {
+    directory: string;
+    view?: never;
+};
+export declare function pushPlan(sessionId: string, body: PlanSource & {
+    projectRoot: string;
+    label?: string;
+    gate?: string;
+}): Promise<PlanResult & {
+    reachable: boolean;
+}>;
+export declare function peekFeedback(sessionId: string): Promise<string | null>;
+export declare function consumeFeedback(sessionId: string): Promise<string | null>;
+export interface BuildEvent {
+    issue?: string;
+    status: string;
+    message?: string;
+    ts?: number;
+}
+export declare function postBuildEvent(event: BuildEvent): Promise<boolean>;
+export declare function waitForFeedback(sessionId: string, timeoutMs?: number): Promise<string>;

package/types/cli/src/daemon-lifecycle.d.ts

@@ -0,0 +1,16 @@
+import { type DaemonLifecycleConfig } from '@fabrika/daemon-kit';
+import type { z } from 'zod';
+import { healthInfoSchema } from '../../shared';
+export type DaemonHealthInfo = z.output<typeof healthInfoSchema> & {
+    pid: number;
+};
+export declare function healthMatchesDataRoot(info: {
+    sessionsDir: string;
+}, expectedSessionsDir?: string): boolean;
+export declare const daemonLifecycleConfig: DaemonLifecycleConfig<DaemonHealthInfo>;
+export declare const daemon: import("@fabrika/daemon-kit").DaemonLifecycle<DaemonHealthInfo>;
+export declare function ensureDaemon(opts?: {
+    quiet?: boolean;
+}): Promise<boolean>;
+export declare function isDaemonRunning(): Promise<boolean>;
+export declare function openBrowser(url: string, fallbackUrl?: string): void;

package/types/cli/src/derive.d.ts

@@ -0,0 +1,17 @@
+import { type Phase, type PhaseId } from '../../shared/phases';
+export interface PhaseState {
+    current: PhaseId;
+    index: number;
+    completed: PhaseId[];
+    reads: string[];
+    produces: string[];
+    gate: boolean;
+    satisfied: boolean;
+}
+export type GateProbe = (phase: Phase) => boolean;
+export declare const offlineGateProbe: GateProbe;
+export declare function matchGlob(repoRoot: string, glob: string): string[];
+export declare function isNonEmptyFile(p: string): boolean;
+export declare function producesSatisfied(repoRoot: string, phase: Phase): boolean;
+export declare function resolveReads(repoRoot: string, phase: Phase): string[];
+export declare function derivePhase(repoRoot: string, gateProbe?: GateProbe): PhaseState;

package/types/cli/src/errors.d.ts

@@ -0,0 +1,2 @@
+export declare class BuilderCliError extends Error {
+}

package/types/cli/src/index.d.ts

@@ -0,0 +1,7 @@
+export { type Phase, PHASE_COUNT, PHASE_IDS, phaseById, type PhaseId, phaseIndex, PHASES } from '../../shared/phases';
+export { resolveCatalogRoot, resolveStackPointer, type StackPointer } from './catalog';
+export { BASE_URL, DAEMON_PORT, DATA_DIR, FABRIKA_DIRNAME, getSessionId, hashRepoPath, NEUTRAL_DATA_DIR, resolveDataDir, TEMP_DIR, WS_URL, } from './config';
+export { derivePhase, type GateProbe, isNonEmptyFile, matchGlob, offlineGateProbe, type PhaseState, producesSatisfied, resolveReads } from './derive';
+export { type AgentHost, injectAgentSupport, type InjectOptions, type InjectResult, injectSkills, parseAgentHosts, resolveSkillSource, } from './inject-skills';
+export { configPath, EXTERNAL_DIRS, type FabrikaConfig, fabrikaDir, findRepoRoot, type InitResult, isInitialized, LAYER_DIRS, readConfig, scaffold, } from './layout';
+export { type PacketJson, packetJson, type RenderOpts, renderPacket } from './packet';

package/types/cli/src/induce.d.ts

@@ -0,0 +1,16 @@
+import type { StackPointer } from './catalog';
+import type { Skeleton } from './skeletons';
+export interface InducedIssue {
+    id: string;
+    goal: string;
+    satisfies: string[];
+    dependsOn: string[];
+    touches: string[];
+    body: string;
+    kind: 'foundation' | 'feature';
+}
+export interface InduceOpts {
+    stack?: StackPointer;
+}
+export declare function induceIssues(skeletons: Skeleton[], opts?: InduceOpts): InducedIssue[];
+export declare function renderIssue(issue: InducedIssue): string;

package/types/cli/src/inject-skills.d.ts

@@ -0,0 +1,23 @@
+export type AgentHost = 'claude' | 'codex';
+export interface InjectOptions {
+    hosts?: AgentHost[];
+}
+/** Where the installed `fabrika-app` skill came from: the application's own `@fabrika/app`, or the builder's. */
+export interface AppSkillSource {
+    from: 'application' | 'builder';
+    version: string;
+}
+export interface InjectResult {
+    sourceDir: string | null;
+    hosts: AgentHost[];
+    appSkill: AppSkillSource | null;
+    written: string[];
+    updated: string[];
+    skipped: string[];
+    preserved: string[];
+}
+export declare function resolveSkillSource(): string | null;
+export declare function parseAgentHosts(value?: string): AgentHost[];
+export declare function injectAgentSupport(repoRoot: string, opts?: InjectOptions): InjectResult;
+export declare function injectSkills(repoRoot: string): InjectResult;
+export declare function manifestRelativePath(repoRoot: string): string;

package/types/cli/src/issues.d.ts

@@ -0,0 +1,12 @@
+export interface Issue {
+    id: string;
+    path: string;
+    goal: string;
+    satisfies: string[];
+    dependsOn: string[];
+    touches: string[];
+    body: string;
+}
+export declare function readIssues(fabrikaDir: string): Issue[];
+export declare function parseIssue(path: string): Issue;
+export declare function isReady(issue: Issue, knownIds: Set<string>): boolean;

package/types/cli/src/layout.d.ts

@@ -0,0 +1,21 @@
+import { type BuilderProjectConfig } from '../../shared';
+export declare const LAYER_DIRS: string[];
+export declare const EXTERNAL_DIRS: string[];
+export type FabrikaConfig = BuilderProjectConfig;
+export declare function fabrikaDir(repoRoot: string): string;
+export declare function configPath(repoRoot: string): string;
+export declare function isInitialized(repoRoot: string): boolean;
+export declare function readConfig(repoRoot: string): FabrikaConfig | null;
+export interface InitResult {
+    repoRoot: string;
+    fabrikaDir: string;
+    config: FabrikaConfig;
+    createdDirs: string[];
+    createdConfig: boolean;
+    alreadyInitialized: boolean;
+}
+export declare function scaffold(repoRoot: string, opts?: {
+    profile?: string;
+    sessionId?: string;
+}): InitResult;
+export declare function findRepoRoot(start?: string): string | null;

package/types/cli/src/packet.d.ts

@@ -0,0 +1,32 @@
+import type { BuilderProjectConnection } from '../../shared';
+import { type PhaseId } from '../../shared/phases';
+import { type StackPointer } from './catalog';
+import type { PhaseState } from './derive';
+export interface RenderOpts {
+    profile?: string;
+    connection?: BuilderProjectConnection;
+}
+export declare function renderPacket(state: PhaseState, opts?: RenderOpts): string;
+export interface PacketJson {
+    phase: PhaseId;
+    index: number;
+    number: number;
+    title: string;
+    reads: string[];
+    produces: string[];
+    gate: boolean;
+    gateView: string | null;
+    skills: string[];
+    completed: PhaseId[];
+    satisfied: boolean;
+    stack: StackPointer | null;
+    platform: ReturnType<typeof connectionContext> | null;
+}
+export declare function packetJson(state: PhaseState, opts?: RenderOpts): PacketJson;
+declare function connectionContext(connection: BuilderProjectConnection): {
+    controlOrigin: string;
+    provider: string;
+    app: import("@fabrika/control-contract").AppDto;
+    environment: import("@fabrika/control-contract").BuilderConnectionEnvironmentDto;
+};
+export {};

package/types/cli/src/phase-state.d.ts

@@ -0,0 +1,6 @@
+import { type PhaseState } from './derive';
+export interface ResolvedPhase {
+    state: PhaseState;
+    source: 'daemon' | 'offline';
+}
+export declare function resolvePhaseState(repoRoot: string, fabrikaDir: string, sessionId?: string): Promise<ResolvedPhase>;

package/types/cli/src/platform-client.d.ts

@@ -0,0 +1,24 @@
+import { type BuilderPlatformStatus, builderProjectPath } from '../../shared';
+export declare function platformRequest(sessionId: string, suffix: Parameters<typeof builderProjectPath>[1], body?: object, timeoutMs?: number): Promise<BuilderPlatformStatus>;
+export declare function publicPlatformStatus(status: BuilderPlatformStatus): {
+    pairing: {
+        expiresAt?: number | undefined;
+        status: "cancelled" | "expired" | "pending" | "approved" | "failed" | "connected" | "recovery_required";
+    } | null;
+    deployment: {
+        message: null;
+        status: "preparing" | "pending" | "running" | "awaiting_approval" | "succeeded" | "failed" | "cancelled";
+        runId: string | null;
+        commitSha: string | null;
+        appUrl: string | null;
+        consoleUrl: string | null;
+    } | null;
+    sessionId: string;
+    projectRoot: string;
+    connection: import("../../shared").BuilderProjectConnection | null;
+    credential: {
+        available: boolean;
+        expiresAt: number | null;
+    };
+    previewUrl: string | null;
+};

package/types/cli/src/skeletons.d.ts

@@ -0,0 +1,11 @@
+export interface Skeleton {
+    file: string;
+    name: string;
+    url?: string;
+    seeds: string[];
+    roles: string[];
+    feature?: string;
+    invariants: string[];
+}
+export declare function readSkeletons(testsBrowserDir: string): Skeleton[];
+export declare function parseSkeletons(file: string): Skeleton[];

package/types/daemon/src/admission.d.ts

@@ -0,0 +1 @@
+export declare function admitRequest(req: Request, url: URL, port: number): Response | null;

package/types/daemon/src/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/types/daemon/src/build-stream.d.ts

@@ -0,0 +1,14 @@
+export interface BuildEvent {
+    issue?: string;
+    status: 'queued' | 'running' | 'passed' | 'failed' | 'blocked' | 'info';
+    message?: string;
+    at?: string;
+    data?: Record<string, unknown>;
+}
+export declare class BuildStream {
+    private events;
+    private subscribers;
+    append(ev: BuildEvent): BuildEvent;
+    history(): BuildEvent[];
+    subscribe(fn: (ev: BuildEvent) => void): () => void;
+}

package/types/daemon/src/handlers.d.ts

@@ -0,0 +1,15 @@
+import { type SessionManager } from '@fabrika/canvas-kernel/server';
+import { type Route } from '@fabrika/daemon-kit';
+import type { BuildStream } from './build-stream';
+import { BuilderPlatform } from './platform';
+export interface HandlerContext {
+    sessionManager: SessionManager;
+    broadcastPlanUpdate: (id: string) => void;
+    broadcastRevisionUpdate: (id: string) => void;
+    buildStream: BuildStream;
+    sessionsDir: string;
+    port: number;
+    version: string;
+    platform?: BuilderPlatform;
+}
+export declare function createHandlers(ctx: HandlerContext): Route[];

package/types/daemon/src/index.d.ts

@@ -0,0 +1,23 @@
+import { SessionManager, type WSData } from '@fabrika/canvas-kernel/server';
+import { type BuilderPlatformOptions } from './platform';
+export { type Phase, type PhaseId, PHASES } from '../../shared/phases';
+export type { BuildEvent } from './build-stream';
+export { derivePhaseState, type PhaseState } from './phases';
+export interface GateRecord {
+    name: string;
+    revision: number;
+    hasFeedback: boolean;
+    consumed: boolean;
+}
+export interface StartDaemonOptions {
+    port?: number;
+    sessionsDir?: string;
+    platform?: BuilderPlatformOptions;
+}
+export interface RunningDaemon {
+    server: import('bun').Server<WSData>;
+    port: number;
+    sessionManager: SessionManager;
+    stop(): void;
+}
+export declare function startDaemon(opts?: StartDaemonOptions): RunningDaemon;

package/types/daemon/src/paths.d.ts

@@ -0,0 +1,10 @@
+export declare const NEUTRAL_DATA_DIR: string;
+export declare function resolveDataDir(argv?: readonly string[], env?: NodeJS.ProcessEnv): string;
+export declare const paths: import("@fabrika/canvas-kernel/server").CanvasPaths;
+export declare const DATA_DIR: string;
+export declare const SESSIONS_DIR: string;
+export declare const TEMP_DIR: string;
+export declare const PID_FILE: string;
+export declare const COMPILE_TEMP_DIR: string;
+export declare const UPLOADS_DIR: string;
+export declare const DEFAULT_PORT: number;

package/types/daemon/src/phases.d.ts

@@ -0,0 +1,21 @@
+import { type Phase, type PhaseId } from '../../shared/phases';
+export interface PhaseState {
+    current: PhaseId;
+    index: number;
+    completed: PhaseId[];
+    reads: string[];
+    produces: string[];
+    gate: boolean;
+    gateName?: string;
+    satisfied: boolean;
+}
+export interface GateOracle {
+    getLatestUnconsumedFeedback(sessionId: string): {
+        revision: number;
+        feedback: string;
+    } | null;
+    hasGateRevision?(sessionId: string, gateName: string): boolean;
+}
+export declare function producesSatisfied(phase: Phase, repoRoot: string): boolean;
+export declare function gateSatisfied(phase: Phase, sessionId: string, oracle?: GateOracle): boolean;
+export declare function derivePhaseState(fabrikaDir: string, sessionId?: string, oracle?: GateOracle): PhaseState;

package/types/daemon/src/platform-compiler.d.ts

@@ -0,0 +1 @@
+export {};