@webpresso/agent-kit 0.21.0

package/dist/esm/blueprint/db/workspace-config.js

@@ -0,0 +1,150 @@
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { Database } from '#db/sqlite.js';
+import { load as yamlLoad } from 'js-yaml';
+import { z } from 'zod';
+const workspaceRepoSchema = z.object({
+    path: z.string(),
+});
+const workspaceConfigSchema = z.object({
+    repos: z.array(workspaceRepoSchema).default([]),
+});
+export function defaultWorkspaceConfigPath() {
+    return path.join(homedir(), '.agent', 'workspace.yaml');
+}
+/**
+ * Read `~/.agent/workspace.yaml`, parse with js-yaml, and validate with Zod.
+ * Returns an empty `{ repos: [] }` config if the file is missing or invalid.
+ */
+export function loadWorkspaceConfig(configPath) {
+    const target = configPath ?? defaultWorkspaceConfigPath();
+    if (!existsSync(target)) {
+        return workspaceConfigSchema.parse({});
+    }
+    try {
+        const raw = readFileSync(target, 'utf8');
+        const parsed = yamlLoad(raw);
+        return workspaceConfigSchema.parse(parsed ?? {});
+    }
+    catch {
+        return workspaceConfigSchema.parse({});
+    }
+}
+/**
+ * Returns expanded absolute paths from `~/.agent/workspace.yaml`.
+ * Expands leading `~` using `os.homedir()`.
+ */
+export function getWorkspaceRepos(configPath) {
+    const config = loadWorkspaceConfig(configPath);
+    return config.repos.map((repo) => expandHome(repo.path));
+}
+function expandHome(repoPath) {
+    if (repoPath.startsWith('~/') || repoPath === '~') {
+        return path.join(homedir(), repoPath.slice(2));
+    }
+    return repoPath;
+}
+/**
+ * Ensure `~/.agent/` directory exists. Used during workspace config
+ * initialisation. Safe on all platforms via `mkdirSync` with `recursive`.
+ */
+export function ensureAgentDir(agentDir) {
+    const target = agentDir ?? path.join(homedir(), '.agent');
+    mkdirSync(target, { recursive: true });
+}
+// ---------------------------------------------------------------------------
+// Workspace repo ingestion into SQLite
+// ---------------------------------------------------------------------------
+/**
+ * Reads `~/.agent/workspace.yaml`, resolves each repo path, detects its
+ * organization (via `git remote get-url origin`) and visibility (via
+ * `gh repo view`), and upserts the results into the `workspace_repos` table.
+ *
+ * Silent on individual repo failures so one bad remote doesn't abort the run.
+ */
+export function ingestWorkspaceRepos(db, cwd) {
+    const repos = getWorkspaceRepos();
+    const upsert = db.prepare(`INSERT INTO workspace_repos (repo_path, organization, repo_name, visibility, last_synced)
+     VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(repo_path) DO UPDATE SET
+       organization = excluded.organization,
+       repo_name    = excluded.repo_name,
+       visibility   = excluded.visibility,
+       last_synced  = excluded.last_synced`);
+    const now = Date.now();
+    for (const repoPath of repos) {
+        try {
+            const org = detectOrgFromPath(repoPath);
+            const repoName = detectRepoNameFromPath(repoPath);
+            const visibility = detectVisibilityFromPath(repoPath);
+            upsert.run(repoPath, org, repoName, visibility, now);
+        }
+        catch {
+            // Skip repos we can't inspect — don't fail the whole ingest
+        }
+    }
+    // Also upsert the current working directory repo
+    try {
+        const org = detectOrgFromPath(cwd);
+        const repoName = detectRepoNameFromPath(cwd);
+        const visibility = detectVisibilityFromPath(cwd);
+        upsert.run(cwd, org, repoName, visibility, now);
+    }
+    catch {
+        // Best-effort
+    }
+}
+function detectOrgFromPath(repoPath) {
+    try {
+        const remote = execSync('git remote get-url origin', {
+            cwd: repoPath,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            encoding: 'utf8',
+            timeout: 5000,
+        }).trim();
+        const match = remote.match(/[:/]([^/]+)\/[^/]+(?:\.git)?$/);
+        if (match?.[1])
+            return match[1];
+    }
+    catch {
+        // silent
+    }
+    return 'unknown';
+}
+function detectRepoNameFromPath(repoPath) {
+    try {
+        const remote = execSync('git remote get-url origin', {
+            cwd: repoPath,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            encoding: 'utf8',
+            timeout: 5000,
+        }).trim();
+        // Extract repo name from "org/repo.git" or "org/repo"
+        const match = remote.match(/\/([^/]+?)(?:\.git)?$/);
+        if (match?.[1])
+            return match[1];
+    }
+    catch {
+        // silent
+    }
+    return path.basename(repoPath);
+}
+function detectVisibilityFromPath(repoPath) {
+    try {
+        const result = execSync('gh repo view --json visibility --jq .visibility', {
+            cwd: repoPath,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            encoding: 'utf8',
+            timeout: 10000,
+        }).trim();
+        if (result.toLowerCase() === 'public')
+            return 'public';
+    }
+    catch {
+        // silent — gh not available or not authenticated
+    }
+    return 'private';
+}
+//# sourceMappingURL=workspace-config.js.map

package/dist/esm/blueprint/evidence.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Evidence Contract (F10 — pinned in
+ * `blueprints/in-progress/structured-blueprint-mcp-sqlite-first-agent-ops`).
+ *
+ * This module is the bedrock of the verification anti-forgery posture:
+ * `wp_blueprint_task_verify` parses caller-supplied evidence through these
+ * zod schemas before the markdown helper or the projection DB is touched.
+ *
+ * Validity rules enforced by the schemas:
+ * - `kind: 'test'`        — requires `command` (non-empty) and `exit_code === 0`
+ *                           when `result === 'pass'`. Any non-zero exit must be
+ *                           paired with `result === 'fail'`.
+ * - `kind: 'integration'` — same as `test`, plus a non-empty `target_files[]`.
+ * - `kind: 'audit'`       — requires `audit_kind` (e.g. `tph-e2e`,
+ *                           `blueprint-lifecycle`) and a `passed: true` flag
+ *                           when `result === 'pass'`.
+ * - `kind: 'manual'`      — requires `actor`, `description`, an explicit
+ *                           `allow_manual: true` (anti-shortcut), and a
+ *                           non-empty `log_excerpt` (≤ 4 KiB).
+ *
+ * Trivial payloads (`{ ok: true }`, `{}`) fail at parse time. The list schema
+ * additionally rejects empty arrays so callers cannot satisfy the contract by
+ * passing zero evidence items.
+ *
+ * Stronger attestation (cryptographic signing of evidence) is explicitly out
+ * of scope — see the blueprint's "Anti-forgery posture" section.
+ */
+import { z } from 'zod';
+export declare const evidenceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    command: z.ZodString;
+    exit_code: z.ZodNumber;
+    result: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+    }>;
+    ts: z.ZodString;
+    agent: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"test">;
+}, z.core.$strict>, z.ZodObject<{
+    target_files: z.ZodArray<z.ZodString>;
+    command: z.ZodString;
+    exit_code: z.ZodNumber;
+    result: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+    }>;
+    ts: z.ZodString;
+    agent: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"integration">;
+}, z.core.$strict>, z.ZodObject<{
+    audit_kind: z.ZodString;
+    passed: z.ZodBoolean;
+    command: z.ZodOptional<z.ZodString>;
+    exit_code: z.ZodOptional<z.ZodNumber>;
+    result: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+    }>;
+    ts: z.ZodString;
+    agent: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"audit">;
+}, z.core.$strict>, z.ZodObject<{
+    actor: z.ZodString;
+    description: z.ZodString;
+    allow_manual: z.ZodLiteral<true>;
+    log_excerpt: z.ZodString;
+    result: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+    }>;
+    ts: z.ZodString;
+    agent: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"manual">;
+}, z.core.$strict>], "kind">;
+export declare const evidenceListSchema: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    command: z.ZodString;
+    exit_code: z.ZodNumber;
+    result: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+    }>;
+    ts: z.ZodString;
+    agent: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"test">;
+}, z.core.$strict>, z.ZodObject<{
+    target_files: z.ZodArray<z.ZodString>;
+    command: z.ZodString;
+    exit_code: z.ZodNumber;
+    result: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+    }>;
+    ts: z.ZodString;
+    agent: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"integration">;
+}, z.core.$strict>, z.ZodObject<{
+    audit_kind: z.ZodString;
+    passed: z.ZodBoolean;
+    command: z.ZodOptional<z.ZodString>;
+    exit_code: z.ZodOptional<z.ZodNumber>;
+    result: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+    }>;
+    ts: z.ZodString;
+    agent: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"audit">;
+}, z.core.$strict>, z.ZodObject<{
+    actor: z.ZodString;
+    description: z.ZodString;
+    allow_manual: z.ZodLiteral<true>;
+    log_excerpt: z.ZodString;
+    result: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+    }>;
+    ts: z.ZodString;
+    agent: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"manual">;
+}, z.core.$strict>], "kind">>;
+export type Evidence = z.infer<typeof evidenceSchema>;
+export type EvidenceKind = Evidence['kind'];
+export type EvidenceList = z.infer<typeof evidenceListSchema>;
+/**
+ * Canonicalize an evidence item to stable JSON.
+ *
+ * Stability rules:
+ * - Object keys are sorted alphabetically.
+ * - Array order is preserved (semantic — e.g. `target_files`).
+ * - No trailing whitespace.
+ *
+ * Used by the verification markdown helper to ensure re-applying the same
+ * evidence produces byte-identical output (idempotency invariant).
+ */
+export declare function canonicalizeEvidence(evidence: Evidence): string;
+/**
+ * Canonicalize a list of evidence items. Order is preserved.
+ */
+export declare function canonicalizeEvidenceList(evidence: readonly Evidence[]): string;
+//# sourceMappingURL=evidence.d.ts.map

package/dist/esm/blueprint/evidence.js

@@ -0,0 +1,152 @@
+/**
+ * Evidence Contract (F10 — pinned in
+ * `blueprints/in-progress/structured-blueprint-mcp-sqlite-first-agent-ops`).
+ *
+ * This module is the bedrock of the verification anti-forgery posture:
+ * `wp_blueprint_task_verify` parses caller-supplied evidence through these
+ * zod schemas before the markdown helper or the projection DB is touched.
+ *
+ * Validity rules enforced by the schemas:
+ * - `kind: 'test'`        — requires `command` (non-empty) and `exit_code === 0`
+ *                           when `result === 'pass'`. Any non-zero exit must be
+ *                           paired with `result === 'fail'`.
+ * - `kind: 'integration'` — same as `test`, plus a non-empty `target_files[]`.
+ * - `kind: 'audit'`       — requires `audit_kind` (e.g. `tph-e2e`,
+ *                           `blueprint-lifecycle`) and a `passed: true` flag
+ *                           when `result === 'pass'`.
+ * - `kind: 'manual'`      — requires `actor`, `description`, an explicit
+ *                           `allow_manual: true` (anti-shortcut), and a
+ *                           non-empty `log_excerpt` (≤ 4 KiB).
+ *
+ * Trivial payloads (`{ ok: true }`, `{}`) fail at parse time. The list schema
+ * additionally rejects empty arrays so callers cannot satisfy the contract by
+ * passing zero evidence items.
+ *
+ * Stronger attestation (cryptographic signing of evidence) is explicitly out
+ * of scope — see the blueprint's "Anti-forgery posture" section.
+ */
+import { z } from 'zod';
+const MANUAL_LOG_MAX_BYTES = 4096;
+const baseFields = {
+    result: z.enum(['pass', 'fail']),
+    ts: z.string().refine((value) => !Number.isNaN(Date.parse(value)), {
+        message: 'ts must be an ISO 8601 date-time string',
+    }),
+    agent: z.string().min(1).optional(),
+};
+const commandExitCodeFields = {
+    command: z.string().min(1),
+    exit_code: z.number().int(),
+};
+const testEvidenceSchema = z
+    .object({
+    kind: z.literal('test'),
+    ...baseFields,
+    ...commandExitCodeFields,
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value.result === 'pass' && value.exit_code !== 0) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['exit_code'],
+            message: 'passing test evidence requires exit_code === 0',
+        });
+    }
+});
+const integrationEvidenceSchema = z
+    .object({
+    kind: z.literal('integration'),
+    ...baseFields,
+    ...commandExitCodeFields,
+    target_files: z.array(z.string().min(1)).min(1),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value.result === 'pass' && value.exit_code !== 0) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['exit_code'],
+            message: 'passing integration evidence requires exit_code === 0',
+        });
+    }
+});
+const auditEvidenceSchema = z
+    .object({
+    kind: z.literal('audit'),
+    ...baseFields,
+    audit_kind: z.string().min(1),
+    passed: z.boolean(),
+    command: z.string().min(1).optional(),
+    exit_code: z.number().int().optional(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value.result === 'pass' && value.passed !== true) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['passed'],
+            message: 'passing audit evidence requires passed: true',
+        });
+    }
+});
+const manualEvidenceSchema = z
+    .object({
+    kind: z.literal('manual'),
+    ...baseFields,
+    actor: z.string().min(1),
+    description: z.string().min(1),
+    // `allow_manual` is the anti-shortcut: agents must opt in explicitly so
+    // manual evidence cannot be accidentally generated as a fallback when a
+    // structured evidence kind is unavailable.
+    allow_manual: z.literal(true),
+    log_excerpt: z
+        .string()
+        .min(1)
+        .refine((value) => Buffer.byteLength(value, 'utf8') <= MANUAL_LOG_MAX_BYTES, {
+        message: `log_excerpt must be ≤ ${MANUAL_LOG_MAX_BYTES} bytes`,
+    }),
+})
+    .strict();
+export const evidenceSchema = z.discriminatedUnion('kind', [
+    testEvidenceSchema,
+    integrationEvidenceSchema,
+    auditEvidenceSchema,
+    manualEvidenceSchema,
+]);
+export const evidenceListSchema = z.array(evidenceSchema).min(1);
+/**
+ * Canonicalize an evidence item to stable JSON.
+ *
+ * Stability rules:
+ * - Object keys are sorted alphabetically.
+ * - Array order is preserved (semantic — e.g. `target_files`).
+ * - No trailing whitespace.
+ *
+ * Used by the verification markdown helper to ensure re-applying the same
+ * evidence produces byte-identical output (idempotency invariant).
+ */
+export function canonicalizeEvidence(evidence) {
+    return JSON.stringify(sortKeys(evidence));
+}
+/**
+ * Canonicalize a list of evidence items. Order is preserved.
+ */
+export function canonicalizeEvidenceList(evidence) {
+    return JSON.stringify(evidence.map((item) => sortKeys(item)));
+}
+function sortKeys(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortKeys);
+    }
+    if (value !== null && typeof value === 'object') {
+        const entries = Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+        const out = {};
+        for (const [k, v] of entries) {
+            out[k] = sortKeys(v);
+        }
+        return out;
+    }
+    return value;
+}
+//# sourceMappingURL=evidence.js.map

package/dist/esm/blueprint/execution/artifacts.d.ts

@@ -0,0 +1,9 @@
+export interface BlueprintExecutionArtifacts {
+    artifacts: string[];
+    logPath?: string;
+    verifications: string[];
+}
+export declare function readBlueprintExecutionArtifacts(markdown: string): BlueprintExecutionArtifacts | null;
+export declare function writeBlueprintExecutionArtifacts(markdown: string, artifacts: BlueprintExecutionArtifacts): string;
+export declare function clearBlueprintExecutionArtifacts(markdown: string): string;
+//# sourceMappingURL=artifacts.d.ts.map

package/dist/esm/blueprint/execution/artifacts.js

@@ -0,0 +1,45 @@
+import matter from 'gray-matter';
+import { setBlueprintFrontmatterFields } from '#lifecycle/engine';
+function normalizeString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed === '' ? undefined : trimmed;
+}
+function normalizeStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((entry) => normalizeString(entry))
+        .filter((entry) => entry !== undefined);
+}
+export function readBlueprintExecutionArtifacts(markdown) {
+    const parsed = matter(markdown);
+    const artifacts = normalizeStringArray(parsed.data.execution_artifacts);
+    const verifications = normalizeStringArray(parsed.data.execution_verifications);
+    const logPath = normalizeString(parsed.data.execution_log_path);
+    if (artifacts.length === 0 && verifications.length === 0 && !logPath) {
+        return null;
+    }
+    return {
+        artifacts,
+        logPath,
+        verifications,
+    };
+}
+export function writeBlueprintExecutionArtifacts(markdown, artifacts) {
+    return setBlueprintFrontmatterFields(markdown, {
+        execution_artifacts: artifacts.artifacts,
+        execution_log_path: artifacts.logPath,
+        execution_verifications: artifacts.verifications,
+    });
+}
+export function clearBlueprintExecutionArtifacts(markdown) {
+    return setBlueprintFrontmatterFields(markdown, {
+        execution_artifacts: undefined,
+        execution_log_path: undefined,
+        execution_verifications: undefined,
+    });
+}
+//# sourceMappingURL=artifacts.js.map

package/dist/esm/blueprint/execution/metadata.d.ts

@@ -0,0 +1,11 @@
+import type { BlueprintExecutionBackendValue, BlueprintExecutionStatusValue } from '#core/schema';
+export interface BlueprintExecutionMetadata {
+    backend: BlueprintExecutionBackendValue;
+    executionId: string;
+    status: BlueprintExecutionStatusValue;
+    updatedAt: string;
+}
+export declare function readBlueprintExecutionMetadata(markdown: string): BlueprintExecutionMetadata | null;
+export declare function writeBlueprintExecutionMetadata(markdown: string, metadata: BlueprintExecutionMetadata): string;
+export declare function clearBlueprintExecutionMetadata(markdown: string): string;
+//# sourceMappingURL=metadata.d.ts.map

package/dist/esm/blueprint/execution/metadata.js

@@ -0,0 +1,46 @@
+import matter from 'gray-matter';
+import { executionBackendSchema, executionStatusSchema } from '#core/schema';
+import { setBlueprintFrontmatterFields } from '#lifecycle/engine';
+function normalizeString(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed === '' ? undefined : trimmed;
+    }
+    if (value instanceof Date && !Number.isNaN(value.getTime())) {
+        return value.toISOString();
+    }
+    return undefined;
+}
+export function readBlueprintExecutionMetadata(markdown) {
+    const parsed = matter(markdown);
+    const backend = executionBackendSchema.safeParse(parsed.data.execution_backend);
+    const status = executionStatusSchema.safeParse(parsed.data.execution_status);
+    const executionId = normalizeString(parsed.data.execution_id);
+    const updatedAt = normalizeString(parsed.data.execution_updated_at);
+    if (!backend.success || !status.success || !executionId || !updatedAt) {
+        return null;
+    }
+    return {
+        backend: backend.data,
+        executionId,
+        status: status.data,
+        updatedAt,
+    };
+}
+export function writeBlueprintExecutionMetadata(markdown, metadata) {
+    return setBlueprintFrontmatterFields(markdown, {
+        execution_backend: metadata.backend,
+        execution_id: metadata.executionId,
+        execution_status: metadata.status,
+        execution_updated_at: metadata.updatedAt,
+    });
+}
+export function clearBlueprintExecutionMetadata(markdown) {
+    return setBlueprintFrontmatterFields(markdown, {
+        execution_backend: undefined,
+        execution_id: undefined,
+        execution_status: undefined,
+        execution_updated_at: undefined,
+    });
+}
+//# sourceMappingURL=metadata.js.map

package/dist/esm/blueprint/execution/progress-bridge.d.ts

@@ -0,0 +1,117 @@
+import type { Blueprint } from '#core/parser';
+import type { BlueprintExecutionMetadata } from '#execution/metadata';
+import type { BlueprintLifecycleIntent } from '#lifecycle/engine';
+import { z } from 'zod';
+import { type BlueprintExecutionBackend, type BlueprintLaunchSpec, type RuntimeStateSnapshot, type RuntimeStateStatus } from './types.js';
+export declare const omxTeamTaskStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    blocked: "blocked";
+    completed: "completed";
+    failed: "failed";
+    in_progress: "in_progress";
+}>;
+export type OmxTeamTaskStatus = z.infer<typeof omxTeamTaskStatusSchema>;
+export declare const omxTeamTaskSnapshotSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        command: z.ZodString;
+        exit_code: z.ZodNumber;
+        result: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+        }>;
+        ts: z.ZodString;
+        agent: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"test">;
+    }, z.core.$strict>, z.ZodObject<{
+        target_files: z.ZodArray<z.ZodString>;
+        command: z.ZodString;
+        exit_code: z.ZodNumber;
+        result: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+        }>;
+        ts: z.ZodString;
+        agent: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"integration">;
+    }, z.core.$strict>, z.ZodObject<{
+        audit_kind: z.ZodString;
+        passed: z.ZodBoolean;
+        command: z.ZodOptional<z.ZodString>;
+        exit_code: z.ZodOptional<z.ZodNumber>;
+        result: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+        }>;
+        ts: z.ZodString;
+        agent: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"audit">;
+    }, z.core.$strict>, z.ZodObject<{
+        actor: z.ZodString;
+        description: z.ZodString;
+        allow_manual: z.ZodLiteral<true>;
+        log_excerpt: z.ZodString;
+        result: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+        }>;
+        ts: z.ZodString;
+        agent: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"manual">;
+    }, z.core.$strict>], "kind">>>;
+    result: z.ZodOptional<z.ZodString>;
+    runtimeTaskId: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        blocked: "blocked";
+        completed: "completed";
+        failed: "failed";
+        in_progress: "in_progress";
+    }>;
+    subject: z.ZodString;
+}, z.core.$strip>;
+export type OmxTeamTaskSnapshot = z.infer<typeof omxTeamTaskSnapshotSchema>;
+export declare const blueprintProgressBridgeTaskBindingSchema: z.ZodObject<{
+    blueprintTaskId: z.ZodString;
+    runtimeTaskId: z.ZodString;
+    title: z.ZodString;
+}, z.core.$strip>;
+export type BlueprintProgressBridgeTaskBinding = z.infer<typeof blueprintProgressBridgeTaskBindingSchema>;
+export declare const blueprintProgressBridgeStateSchema: z.ZodObject<{
+    backend: z.ZodEnum<{
+        "omx-team": "omx-team";
+        "omx-pll-interactive": "omx-pll-interactive";
+        "claude-subagent": "claude-subagent";
+        "codex-exec": "codex-exec";
+        "local-worktree": "local-worktree";
+    }>;
+    blueprintPath: z.ZodString;
+    blueprintSlug: z.ZodString;
+    executionId: z.ZodString;
+    tasks: z.ZodArray<z.ZodObject<{
+        blueprintTaskId: z.ZodString;
+        runtimeTaskId: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strip>>;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type BlueprintProgressBridgeState = z.infer<typeof blueprintProgressBridgeStateSchema>;
+export interface BlueprintProgressBridgeProjection {
+    intents: BlueprintLifecycleIntent[];
+    status: RuntimeStateStatus;
+}
+export interface RuntimeProgressBridgeResult {
+    appliedTransitions: string[];
+    blueprint: Blueprint;
+    execution: BlueprintExecutionMetadata;
+    markdown: string;
+}
+export declare function buildBlueprintProgressBridgeState(spec: BlueprintLaunchSpec, executionId: string, runtimeTasks: OmxTeamTaskSnapshot[], updatedAt: string): BlueprintProgressBridgeState;
+export declare function projectBlueprintLifecycleFromRuntime(blueprint: Blueprint, bridge: BlueprintProgressBridgeState, runtimeTasks: OmxTeamTaskSnapshot[]): BlueprintProgressBridgeProjection;
+export declare function normalizeOmxTeamTaskSnapshot(input: Record<string, unknown>): OmxTeamTaskSnapshot;
+export declare function sanitizeBlueprintExecutionId(executionId: string): string;
+export declare function resolveBlueprintProgressBridgePath(runtimeStateRoot: string, backend: BlueprintExecutionBackend, executionId: string): string;
+export declare function runtimeSnapshotPathForExecution(executionId: string, runtimeStateRoot?: string): string;
+export declare function applyRuntimeProgressSnapshot(markdown: string, slug: string, input: RuntimeStateSnapshot): RuntimeProgressBridgeResult;
+//# sourceMappingURL=progress-bridge.d.ts.map