@jmanuelcorral/openteam 0.19.0 → 0.20.0

package/dist/lifecycle/historySourceError.d.ts

@@ -0,0 +1,7 @@
+import type { LifecycleHistoryErrorCode } from "./contracts";
+/** Internal read-boundary failure; never carries a filesystem error or cause. */
+export declare class LifecycleHistorySourceError extends Error {
+    readonly code: Extract<LifecycleHistoryErrorCode, "journal-corrupt" | "history-unavailable">;
+    constructor(code: Extract<LifecycleHistoryErrorCode, "journal-corrupt" | "history-unavailable">);
+}
+//# sourceMappingURL=historySourceError.d.ts.map

package/dist/lifecycle/historySourceError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"historySourceError.d.ts","sourceRoot":"","sources":["../../src/lifecycle/historySourceError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAE7D,iFAAiF;AACjF,qBAAa,2BAA4B,SAAQ,KAAK;IAElD,QAAQ,CAAC,IAAI,EAAE,OAAO,CACpB,yBAAyB,EACzB,iBAAiB,GAAG,qBAAqB,CAC1C;IAJH,YACW,IAAI,EAAE,OAAO,CACpB,yBAAyB,EACzB,iBAAiB,GAAG,qBAAqB,CAC1C,EAIF;CACF"}

package/dist/lifecycle/project.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectLifecyclePrefix } from "./contracts";
+export declare const projectLifecyclePrefix: ProjectLifecyclePrefix;
+//# sourceMappingURL=project.d.ts.map

package/dist/lifecycle/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../src/lifecycle/project.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAQV,sBAAsB,EACvB,MAAM,aAAa,CAAC;AA0ErB,eAAO,MAAM,sBAAsB,EAAE,sBAkOpC,CAAC"}

package/dist/lifecycle/root.d.ts

@@ -0,0 +1,3 @@
+import type { ResolveLifecycleRoot } from "./contracts";
+export declare const resolveLifecycleRoot: ResolveLifecycleRoot;
+//# sourceMappingURL=root.d.ts.map

package/dist/lifecycle/root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../../src/lifecycle/root.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAEV,oBAAoB,EACrB,MAAM,aAAa,CAAC;AAErB,eAAO,MAAM,oBAAoB,EAAE,oBAmBlC,CAAC"}

package/dist/lifecycle/runtimeRecorder.d.ts

@@ -0,0 +1,6 @@
+import type { CreateNodeLifecycleHeartbeatScheduler, CreateRuntimeLifecycleRecorder } from "./contracts";
+export declare const DEFAULT_LIFECYCLE_HEARTBEAT_INTERVAL_MS = 5000;
+export declare const DEFAULT_LIFECYCLE_WRITER_LEASE_MS = 30000;
+export declare const createNodeLifecycleHeartbeatScheduler: CreateNodeLifecycleHeartbeatScheduler;
+export declare const createRuntimeLifecycleRecorder: CreateRuntimeLifecycleRecorder;
+//# sourceMappingURL=runtimeRecorder.d.ts.map

package/dist/lifecycle/runtimeRecorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeRecorder.d.ts","sourceRoot":"","sources":["../../src/lifecycle/runtimeRecorder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qCAAqC,EACrC,8BAA8B,EAe/B,MAAM,aAAa,CAAC;AAGrB,eAAO,MAAM,uCAAuC,OAAQ,CAAC;AAC7D,eAAO,MAAM,iCAAiC,QAAS,CAAC;AAExD,eAAO,MAAM,qCAAqC,EAAE,qCAkChD,CAAC;AAySL,eAAO,MAAM,8BAA8B,EAAE,8BAuL5C,CAAC"}

package/dist/lifecycle/schema.d.ts

@@ -0,0 +1,487 @@
+import { z } from "zod";
+import type { LifecycleAppendEventV1, LifecycleEventV1, LifecycleRunMetadataV1, LifecycleRunStartInput, LifecycleWriterLeaseInput, LifecycleWriterLeaseV1 } from "./contracts";
+export declare const LifecycleRunMetadataSchema: z.ZodObject<{
+    runID: z.ZodString;
+    source: z.ZodEnum<{
+        cli: "cli";
+        plugin: "plugin";
+    }>;
+    executionAuthority: z.ZodEnum<{
+        coordinator: "coordinator";
+        graph: "graph";
+    }>;
+    root: z.ZodObject<{
+        operationID: z.ZodString;
+        taskID: z.ZodString;
+        kind: z.ZodEnum<{
+            coordinator: "coordinator";
+            "graph-node": "graph-node";
+        }>;
+        roleID: z.ZodString;
+        agentID: z.ZodOptional<z.ZodString>;
+        sessionID: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    version: z.ZodLiteral<1>;
+    createdAt: z.ZodNumber;
+}, z.core.$strict>;
+export declare const LifecycleAppendEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"operation.queued">;
+    operationID: z.ZodString;
+    taskID: z.ZodString;
+    kind: z.ZodEnum<{
+        "graph-node": "graph-node";
+        role: "role";
+    }>;
+    roleID: z.ZodString;
+    agentID: z.ZodOptional<z.ZodString>;
+    parentOperationID: z.ZodString;
+    dependsOnOperationIDs: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    operationID: z.ZodString;
+    taskID: z.ZodString;
+    attemptID: z.ZodString;
+    attempt: z.ZodNumber;
+    modelIndex: z.ZodNumber;
+    retryIndex: z.ZodNumber;
+    type: z.ZodLiteral<"attempt.model-selected">;
+    decisionID: z.ZodString;
+    model: z.ZodObject<{
+        providerID: z.ZodString;
+        modelID: z.ZodString;
+    }, z.core.$strict>;
+    routeKind: z.ZodEnum<{
+        frontier: "frontier";
+        local: "local";
+    }>;
+    selectionCause: z.ZodEnum<{
+        "fallback-incomplete": "fallback-incomplete";
+        "fallback-transport": "fallback-transport";
+        initial: "initial";
+        "retry-incomplete": "retry-incomplete";
+        "retry-transport": "retry-transport";
+    }>;
+    runtimeID: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    operationID: z.ZodString;
+    taskID: z.ZodString;
+    attemptID: z.ZodString;
+    attempt: z.ZodNumber;
+    modelIndex: z.ZodNumber;
+    retryIndex: z.ZodNumber;
+    type: z.ZodLiteral<"attempt.queued">;
+    runtimeID: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    operationID: z.ZodString;
+    taskID: z.ZodString;
+    attemptID: z.ZodString;
+    attempt: z.ZodNumber;
+    modelIndex: z.ZodNumber;
+    retryIndex: z.ZodNumber;
+    type: z.ZodLiteral<"attempt.started">;
+}, z.core.$strict>, z.ZodObject<{
+    operationID: z.ZodString;
+    taskID: z.ZodString;
+    attemptID: z.ZodString;
+    attempt: z.ZodNumber;
+    modelIndex: z.ZodNumber;
+    retryIndex: z.ZodNumber;
+    type: z.ZodLiteral<"session.created">;
+    sessionID: z.ZodString;
+    parentSessionID: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    operationID: z.ZodString;
+    taskID: z.ZodString;
+    attemptID: z.ZodString;
+    attempt: z.ZodNumber;
+    modelIndex: z.ZodNumber;
+    retryIndex: z.ZodNumber;
+    type: z.ZodLiteral<"attempt.terminal">;
+    outcome: z.ZodEnum<{
+        cancelled: "cancelled";
+        failed: "failed";
+        interrupted: "interrupted";
+        succeeded: "succeeded";
+        unknown: "unknown";
+    }>;
+    continuation: z.ZodEnum<{
+        "fallback-next-model": "fallback-next-model";
+        none: "none";
+        "retry-same-effect": "retry-same-effect";
+        "retry-same-model": "retry-same-model";
+    }>;
+    sessionID: z.ZodOptional<z.ZodString>;
+    failure: z.ZodOptional<z.ZodObject<{
+        class: z.ZodEnum<{
+            "budget-exhausted": "budget-exhausted";
+            cancelled: "cancelled";
+            "create-no-id": "create-no-id";
+            "create-rejected": "create-rejected";
+            "dependency-failed": "dependency-failed";
+            interrupted: "interrupted";
+            "prompt-auth": "prompt-auth";
+            "prompt-connection": "prompt-connection";
+            "prompt-content-filter": "prompt-content-filter";
+            "prompt-context-length": "prompt-context-length";
+            "prompt-rate-limited": "prompt-rate-limited";
+            "prompt-rejected": "prompt-rejected";
+            "prompt-server": "prompt-server";
+            "prompt-stop-unconfirmed": "prompt-stop-unconfirmed";
+            "prompt-timeout": "prompt-timeout";
+            "prompt-validation": "prompt-validation";
+            "report-incomplete": "report-incomplete";
+            "report-not-durable": "report-not-durable";
+            "routing-blocked": "routing-blocked";
+            unknown: "unknown";
+        }>;
+        statusCode: z.ZodOptional<z.ZodNumber>;
+        retryable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"operation.terminal">;
+    operationID: z.ZodString;
+    taskID: z.ZodString;
+    outcome: z.ZodEnum<{
+        blocked: "blocked";
+        cancelled: "cancelled";
+        failed: "failed";
+        interrupted: "interrupted";
+        succeeded: "succeeded";
+        unknown: "unknown";
+    }>;
+    attemptCount: z.ZodNumber;
+    finalSessionID: z.ZodOptional<z.ZodString>;
+    failure: z.ZodOptional<z.ZodObject<{
+        class: z.ZodEnum<{
+            "budget-exhausted": "budget-exhausted";
+            cancelled: "cancelled";
+            "create-no-id": "create-no-id";
+            "create-rejected": "create-rejected";
+            "dependency-failed": "dependency-failed";
+            interrupted: "interrupted";
+            "prompt-auth": "prompt-auth";
+            "prompt-connection": "prompt-connection";
+            "prompt-content-filter": "prompt-content-filter";
+            "prompt-context-length": "prompt-context-length";
+            "prompt-rate-limited": "prompt-rate-limited";
+            "prompt-rejected": "prompt-rejected";
+            "prompt-server": "prompt-server";
+            "prompt-stop-unconfirmed": "prompt-stop-unconfirmed";
+            "prompt-timeout": "prompt-timeout";
+            "prompt-validation": "prompt-validation";
+            "report-incomplete": "report-incomplete";
+            "report-not-durable": "report-not-durable";
+            "routing-blocked": "routing-blocked";
+            unknown: "unknown";
+        }>;
+        statusCode: z.ZodOptional<z.ZodNumber>;
+        retryable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"run.terminal">;
+    outcome: z.ZodEnum<{
+        cancelled: "cancelled";
+        failed: "failed";
+        interrupted: "interrupted";
+        succeeded: "succeeded";
+        unknown: "unknown";
+    }>;
+    operationCount: z.ZodNumber;
+    failure: z.ZodOptional<z.ZodObject<{
+        class: z.ZodEnum<{
+            "budget-exhausted": "budget-exhausted";
+            cancelled: "cancelled";
+            "create-no-id": "create-no-id";
+            "create-rejected": "create-rejected";
+            "dependency-failed": "dependency-failed";
+            interrupted: "interrupted";
+            "prompt-auth": "prompt-auth";
+            "prompt-connection": "prompt-connection";
+            "prompt-content-filter": "prompt-content-filter";
+            "prompt-context-length": "prompt-context-length";
+            "prompt-rate-limited": "prompt-rate-limited";
+            "prompt-rejected": "prompt-rejected";
+            "prompt-server": "prompt-server";
+            "prompt-stop-unconfirmed": "prompt-stop-unconfirmed";
+            "prompt-timeout": "prompt-timeout";
+            "prompt-validation": "prompt-validation";
+            "report-incomplete": "report-incomplete";
+            "report-not-durable": "report-not-durable";
+            "routing-blocked": "routing-blocked";
+            unknown: "unknown";
+        }>;
+        statusCode: z.ZodOptional<z.ZodNumber>;
+        retryable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "type">;
+export declare const LifecycleEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+    at: z.ZodNumber;
+    type: z.ZodLiteral<"run.started">;
+    source: z.ZodEnum<{
+        cli: "cli";
+        plugin: "plugin";
+    }>;
+    executionAuthority: z.ZodEnum<{
+        coordinator: "coordinator";
+        graph: "graph";
+    }>;
+    root: z.ZodObject<{
+        operationID: z.ZodString;
+        taskID: z.ZodString;
+        kind: z.ZodEnum<{
+            coordinator: "coordinator";
+            "graph-node": "graph-node";
+        }>;
+        roleID: z.ZodString;
+        agentID: z.ZodOptional<z.ZodString>;
+        sessionID: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+    at: z.ZodNumber;
+    type: z.ZodLiteral<"operation.queued">;
+    operationID: z.ZodString;
+    taskID: z.ZodString;
+    kind: z.ZodEnum<{
+        "graph-node": "graph-node";
+        role: "role";
+    }>;
+    roleID: z.ZodString;
+    agentID: z.ZodOptional<z.ZodString>;
+    parentOperationID: z.ZodString;
+    dependsOnOperationIDs: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    operationID: z.ZodString;
+    taskID: z.ZodString;
+    attemptID: z.ZodString;
+    attempt: z.ZodNumber;
+    modelIndex: z.ZodNumber;
+    retryIndex: z.ZodNumber;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+    at: z.ZodNumber;
+    type: z.ZodLiteral<"attempt.model-selected">;
+    decisionID: z.ZodString;
+    model: z.ZodObject<{
+        providerID: z.ZodString;
+        modelID: z.ZodString;
+    }, z.core.$strict>;
+    routeKind: z.ZodEnum<{
+        frontier: "frontier";
+        local: "local";
+    }>;
+    selectionCause: z.ZodEnum<{
+        "fallback-incomplete": "fallback-incomplete";
+        "fallback-transport": "fallback-transport";
+        initial: "initial";
+        "retry-incomplete": "retry-incomplete";
+        "retry-transport": "retry-transport";
+    }>;
+    runtimeID: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    operationID: z.ZodString;
+    taskID: z.ZodString;
+    attemptID: z.ZodString;
+    attempt: z.ZodNumber;
+    modelIndex: z.ZodNumber;
+    retryIndex: z.ZodNumber;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+    at: z.ZodNumber;
+    type: z.ZodLiteral<"attempt.queued">;
+    runtimeID: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    operationID: z.ZodString;
+    taskID: z.ZodString;
+    attemptID: z.ZodString;
+    attempt: z.ZodNumber;
+    modelIndex: z.ZodNumber;
+    retryIndex: z.ZodNumber;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+    at: z.ZodNumber;
+    type: z.ZodLiteral<"attempt.started">;
+}, z.core.$strict>, z.ZodObject<{
+    operationID: z.ZodString;
+    taskID: z.ZodString;
+    attemptID: z.ZodString;
+    attempt: z.ZodNumber;
+    modelIndex: z.ZodNumber;
+    retryIndex: z.ZodNumber;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+    at: z.ZodNumber;
+    type: z.ZodLiteral<"session.created">;
+    sessionID: z.ZodString;
+    parentSessionID: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    operationID: z.ZodString;
+    taskID: z.ZodString;
+    attemptID: z.ZodString;
+    attempt: z.ZodNumber;
+    modelIndex: z.ZodNumber;
+    retryIndex: z.ZodNumber;
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+    at: z.ZodNumber;
+    type: z.ZodLiteral<"attempt.terminal">;
+    outcome: z.ZodEnum<{
+        cancelled: "cancelled";
+        failed: "failed";
+        interrupted: "interrupted";
+        succeeded: "succeeded";
+        unknown: "unknown";
+    }>;
+    continuation: z.ZodEnum<{
+        "fallback-next-model": "fallback-next-model";
+        none: "none";
+        "retry-same-effect": "retry-same-effect";
+        "retry-same-model": "retry-same-model";
+    }>;
+    sessionID: z.ZodOptional<z.ZodString>;
+    failure: z.ZodOptional<z.ZodObject<{
+        class: z.ZodEnum<{
+            "budget-exhausted": "budget-exhausted";
+            cancelled: "cancelled";
+            "create-no-id": "create-no-id";
+            "create-rejected": "create-rejected";
+            "dependency-failed": "dependency-failed";
+            interrupted: "interrupted";
+            "prompt-auth": "prompt-auth";
+            "prompt-connection": "prompt-connection";
+            "prompt-content-filter": "prompt-content-filter";
+            "prompt-context-length": "prompt-context-length";
+            "prompt-rate-limited": "prompt-rate-limited";
+            "prompt-rejected": "prompt-rejected";
+            "prompt-server": "prompt-server";
+            "prompt-stop-unconfirmed": "prompt-stop-unconfirmed";
+            "prompt-timeout": "prompt-timeout";
+            "prompt-validation": "prompt-validation";
+            "report-incomplete": "report-incomplete";
+            "report-not-durable": "report-not-durable";
+            "routing-blocked": "routing-blocked";
+            unknown: "unknown";
+        }>;
+        statusCode: z.ZodOptional<z.ZodNumber>;
+        retryable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+    at: z.ZodNumber;
+    type: z.ZodLiteral<"operation.terminal">;
+    operationID: z.ZodString;
+    taskID: z.ZodString;
+    outcome: z.ZodEnum<{
+        blocked: "blocked";
+        cancelled: "cancelled";
+        failed: "failed";
+        interrupted: "interrupted";
+        succeeded: "succeeded";
+        unknown: "unknown";
+    }>;
+    attemptCount: z.ZodNumber;
+    finalSessionID: z.ZodOptional<z.ZodString>;
+    failure: z.ZodOptional<z.ZodObject<{
+        class: z.ZodEnum<{
+            "budget-exhausted": "budget-exhausted";
+            cancelled: "cancelled";
+            "create-no-id": "create-no-id";
+            "create-rejected": "create-rejected";
+            "dependency-failed": "dependency-failed";
+            interrupted: "interrupted";
+            "prompt-auth": "prompt-auth";
+            "prompt-connection": "prompt-connection";
+            "prompt-content-filter": "prompt-content-filter";
+            "prompt-context-length": "prompt-context-length";
+            "prompt-rate-limited": "prompt-rate-limited";
+            "prompt-rejected": "prompt-rejected";
+            "prompt-server": "prompt-server";
+            "prompt-stop-unconfirmed": "prompt-stop-unconfirmed";
+            "prompt-timeout": "prompt-timeout";
+            "prompt-validation": "prompt-validation";
+            "report-incomplete": "report-incomplete";
+            "report-not-durable": "report-not-durable";
+            "routing-blocked": "routing-blocked";
+            unknown: "unknown";
+        }>;
+        statusCode: z.ZodOptional<z.ZodNumber>;
+        retryable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    runID: z.ZodString;
+    at: z.ZodNumber;
+    type: z.ZodLiteral<"run.terminal">;
+    outcome: z.ZodEnum<{
+        cancelled: "cancelled";
+        failed: "failed";
+        interrupted: "interrupted";
+        succeeded: "succeeded";
+        unknown: "unknown";
+    }>;
+    operationCount: z.ZodNumber;
+    failure: z.ZodOptional<z.ZodObject<{
+        class: z.ZodEnum<{
+            "budget-exhausted": "budget-exhausted";
+            cancelled: "cancelled";
+            "create-no-id": "create-no-id";
+            "create-rejected": "create-rejected";
+            "dependency-failed": "dependency-failed";
+            interrupted: "interrupted";
+            "prompt-auth": "prompt-auth";
+            "prompt-connection": "prompt-connection";
+            "prompt-content-filter": "prompt-content-filter";
+            "prompt-context-length": "prompt-context-length";
+            "prompt-rate-limited": "prompt-rate-limited";
+            "prompt-rejected": "prompt-rejected";
+            "prompt-server": "prompt-server";
+            "prompt-stop-unconfirmed": "prompt-stop-unconfirmed";
+            "prompt-timeout": "prompt-timeout";
+            "prompt-validation": "prompt-validation";
+            "report-incomplete": "report-incomplete";
+            "report-not-durable": "report-not-durable";
+            "routing-blocked": "routing-blocked";
+            unknown: "unknown";
+        }>;
+        statusCode: z.ZodOptional<z.ZodNumber>;
+        retryable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "type">;
+export declare const LifecycleWriterLeaseInputSchema: z.ZodObject<{
+    writer: z.ZodObject<{
+        processID: z.ZodNumber;
+        processInstanceID: z.ZodString;
+    }, z.core.$strict>;
+    now: z.ZodNumber;
+    leaseDurationMs: z.ZodNumber;
+}, z.core.$strict>;
+export declare const LifecycleWriterLeaseSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    runID: z.ZodString;
+    writerToken: z.ZodString;
+    processID: z.ZodNumber;
+    processInstanceID: z.ZodString;
+    acquiredAt: z.ZodNumber;
+    heartbeatAt: z.ZodNumber;
+    expiresAt: z.ZodNumber;
+}, z.core.$strict>;
+export declare function assertLifecycleReferenceOnly(value: unknown): void;
+export declare function parseLifecycleRunStartInput(value: unknown): LifecycleRunStartInput;
+export declare function parseLifecycleRunMetadata(value: unknown): LifecycleRunMetadataV1;
+export declare function parseLifecycleAppendEvent(value: unknown): LifecycleAppendEventV1;
+export declare function parseLifecycleEvent(value: unknown): LifecycleEventV1;
+export declare function parseLifecycleWriterLeaseInput(value: unknown): LifecycleWriterLeaseInput;
+export declare function parseLifecycleWriterLease(value: unknown): LifecycleWriterLeaseV1;
+//# sourceMappingURL=schema.d.ts.map

package/dist/lifecycle/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/lifecycle/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EACV,sBAAsB,EACtB,gBAAgB,EAChB,sBAAsB,EACtB,sBAAsB,EACtB,yBAAyB,EACzB,sBAAsB,EACvB,MAAM,aAAa,CAAC;AA8DrB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;kBAK5B,CAAC;AA+IZ,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGtC,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAU/B,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;kBAWjC,CAAC;AAEZ,eAAO,MAAM,0BAA0B;;;;;;;;;kBA2BnC,CAAC;AAwBL,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAEjE;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,OAAO,GACb,sBAAsB,CAIxB;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,GACb,sBAAsB,CAIxB;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,GACb,sBAAsB,CAIxB;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAIpE;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,OAAO,GACb,yBAAyB,CAE3B;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,GACb,sBAAsB,CAIxB"}

package/dist/messages/index.d.ts

@@ -44,4 +44,5 @@
  */
 export * from "./commands";
 export * from "./executionSetup";
+export * from "./lifecycle";
 //# sourceMappingURL=index.d.ts.map

package/dist/messages/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/messages/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/messages/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC"}

package/dist/messages/lifecycle.d.ts

@@ -0,0 +1,95 @@
+/**
+ * User-facing messages for the lifecycle history timeline UI.
+ * Pure catalog — no I/O, no runtime, no locale loader.
+ */
+export declare const lifecycleMessages: {
+    readonly screenLabel: "Lifecycle operation tree";
+    readonly screenHeading: "Agent timeline";
+    readonly screenHeadingLive: "Agent timeline · live";
+    readonly screenHeadingHistorical: "Agent timeline · historical";
+    readonly screenHeadingCompleted: "Agent timeline · completed";
+    readonly screenDescription: "Committed runtime hierarchy for the selected lifecycle run.";
+    readonly screenDescriptionLive: "Following committed lifecycle events from the active writer.";
+    readonly screenDescriptionHistorical: "Historical hierarchy at the selected exclusive event cursor.";
+    readonly screenDescriptionCompleted: "Final committed runtime hierarchy for the completed run.";
+    readonly screenDescriptionUnavailable: "Lifecycle history is not available for the current selection.";
+    readonly panelEyebrow: "Lifecycle run";
+    readonly hierarchyTitle: "Execution hierarchy";
+    readonly hierarchyAriaLabel: "Lifecycle operation hierarchy";
+    readonly cursorCountTemplate: "{cursor} of {head} events";
+    readonly cursorCountSingleTemplate: "{cursor} of {head} event";
+    readonly latestEventLabel: "Latest event";
+    readonly noEventTimestamp: "No event timestamp in this prefix";
+    readonly noRunsYet: "No lifecycle runs yet. The timeline fills when the orchestrator begins a run.";
+    readonly runSelectorLabel: "Select run";
+    readonly runSelectorAriaLabel: "Lifecycle run selector";
+    readonly sliderLabel: "Event cursor";
+    readonly sliderAriaLabel: "Timeline cursor — drag to scrub through lifecycle events";
+    readonly returnToLive: "Return to live";
+    readonly returnToLiveAriaLabel: "Return to live — follow the latest events";
+    readonly pausedLabel: "Paused";
+    readonly latestLabel: "Latest";
+    readonly followingHeadLabel: "Following head";
+    readonly live: "Live";
+    readonly liveAriaLabel: "Live — following the latest events";
+    readonly writerActive: "Writer active";
+    readonly writerUnknown: "Writer unknown";
+    readonly terminal: "Completed";
+    readonly historicalPrefix: "Historical snapshot";
+    readonly legacySnapshot: "Legacy snapshot";
+    readonly operationLabel: "Operation";
+    readonly taskLabel: "Task";
+    readonly roleLabel: "Role";
+    readonly kindLabel: "Kind";
+    readonly agentLabel: "Agent";
+    readonly attemptsLabel: "Attempts";
+    readonly noAttempts: "No attempts in this prefix";
+    readonly attemptLabelTemplate: "Attempt {n}";
+    readonly retryLabel: "Retry";
+    readonly retryLabelTemplate: "Retry {n}";
+    readonly stateLabel: "State";
+    readonly modelLabel: "Model";
+    readonly noModel: "No model recorded";
+    readonly routeLabel: "Route";
+    readonly noRoute: "No route recorded";
+    readonly selectionLabel: "Selection";
+    readonly runtimeLabel: "Runtime";
+    readonly sessionLabel: "Session";
+    readonly noSession: "No session recorded";
+    readonly parentSessionLabel: "Parent session";
+    readonly dependsOnLabel: "Depends on";
+    readonly missingOperation: "missing operation";
+    readonly parentReferenceLabel: "Parent reference";
+    readonly unlinkedOperationsLabel: "Unlinked operations";
+    readonly unlinkedOperationsNote: "These operations are not connected to the selected root in this prefix.";
+    readonly rootOperationMissing: "The selected root operation is not available in this prefix.";
+    readonly noOperationsAtCursor: "No operations exist at this cursor.";
+    readonly selectedAtLabel: "Selected";
+    readonly queuedAtLabel: "Queued";
+    readonly startedAtLabel: "Started";
+    readonly terminalAtLabel: "Finished";
+    readonly failureLabel: "Failure";
+    readonly statusCodeLabel: "Status";
+    readonly retryableLabel: "Retryable";
+    readonly yesLabel: "yes";
+    readonly noLabel: "no";
+    readonly graphSupplementTitle: "Graph execution snapshot";
+    readonly graphSupplementSummary: "Show the separate Graph projection and conversation drill-down";
+    readonly legacyIncomplete: "Legacy artifact — chronology, retry history, and session tree unavailable.";
+    readonly partialTail: "Recording degraded — the tree shows only the committed prefix returned by history.";
+    readonly errorRunNotFound: "Run not found.";
+    readonly errorCursorAhead: "Cursor is ahead of current head.";
+    readonly errorHistoryIncomplete: "Cursor scrubbing is unavailable for legacy artifacts.";
+    readonly errorJournalCorrupt: "Journal is corrupt — history unavailable.";
+    readonly errorHistoryUnavailable: "History storage unavailable.";
+    readonly errorInvalidCursor: "Invalid cursor value.";
+    readonly errorLoading: "Could not load lifecycle history.";
+    readonly graphDisabledHistory: "Lifecycle history is unavailable because the graph engine is off.";
+    readonly historyDisabled: "Lifecycle history is disabled. Enable it in .opencode/openteam.json.";
+    readonly timelineRegionLabel: "Lifecycle timeline";
+    readonly runDetailsLabel: "Run details";
+    readonly controlsLabel: "Timeline controls";
+    readonly eventsCountLabel: (count: number) => string;
+    readonly incomingCountLabel: (count: number) => string;
+};
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/messages/lifecycle.d.ts.map

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

package/dist/messages/lifecycleRuntime.d.ts

@@ -0,0 +1,4 @@
+import type { BoundedNormalizedSessionFailure, LifecycleRecordingStatus } from "../lifecycle/contracts";
+export declare function normalizedSessionFailureMessage(failure: BoundedNormalizedSessionFailure): string;
+export declare function lifecycleRecordingAdvisory(status: LifecycleRecordingStatus): string | undefined;
+//# sourceMappingURL=lifecycleRuntime.d.ts.map

package/dist/messages/lifecycleRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycleRuntime.d.ts","sourceRoot":"","sources":["../../src/messages/lifecycleRuntime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,+BAA+B,EAC/B,wBAAwB,EACzB,MAAM,wBAAwB,CAAC;AAEhC,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,+BAA+B,GACvC,MAAM,CAER;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,wBAAwB,GAC/B,MAAM,GAAG,SAAS,CAOpB"}

package/dist/messages/lifecycleStorage.d.ts

@@ -0,0 +1,4 @@
+export declare const lifecycleStorageMessages: {
+    readonly configuredRootEscapesWorkspace: "Configured lifecycle root must remain beneath the workspace root.";
+};
+//# sourceMappingURL=lifecycleStorage.d.ts.map

package/dist/messages/lifecycleStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycleStorage.d.ts","sourceRoot":"","sources":["../../src/messages/lifecycleStorage.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,wBAAwB;aACnC,8BAA8B,EAC5B,mEAAmE;CAC7D,CAAC"}