@jmanuelcorral/openteam 0.19.0 → 0.21.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/consoleDetail.d.ts

@@ -0,0 +1,54 @@
+export declare const consoleDetailMessages: {
+    readonly follow: "Follow new activity";
+    readonly metadataOnly: "Lifecycle and telemetry stay metadata-only.";
+    readonly filter: "Filter sessions";
+    readonly incoming: "New activity available — show updates";
+    readonly refreshError: "Live updates unavailable; retrying.";
+    readonly inspectConversation: "Show messages and tool calls";
+    readonly refresh: "Refresh conversation";
+    readonly close: "Hide messages and tool calls";
+    readonly title: "Recorded messages and tool calls";
+    readonly orchestrator: "Orchestrator";
+    readonly worker: "Worker";
+    readonly session: "Session";
+    readonly runStarted: "Run started";
+    readonly sessionCreated: "Session created";
+    readonly firstObserved: "First observed";
+    readonly timeUnknown: "Time unknown";
+    readonly utc: "UTC";
+    readonly technicalID: "Technical ID";
+    readonly currentMetadata: "Current opencode title; not historical metadata";
+    readonly partialMetadata: "Some current session titles are unavailable or outside the bounded batch; fallback labels remain.";
+    readonly rootCurrent: "Current whole orchestrator session; may contain multiple batches. Not a historical or batch-only transcript.";
+    readonly recovered: "Read-only association verified from current opencode history; not an immutable lifecycle event.";
+    readonly rootUnlinked: "Orchestrator session not recorded. Reveal to try a bounded, read-only relationship search.";
+    readonly rootUnavailable: "Orchestrator session unavailable: no unique, verifiable relationship was found in local history.";
+    readonly rootAmbiguous: "Orchestrator session unavailable: conflicting or copied relationships are ambiguous.";
+    readonly searchIncomplete: "Orchestrator association search incomplete or exceeded its bounded budget. No session was guessed.";
+    readonly prompt: "Received prompts";
+    readonly assistant: "Visible agent responses";
+    readonly tools: "Tool calls ({count})";
+    readonly noPrompts: "No received prompt text retained.";
+    readonly noOutput: "No visible agent response text retained.";
+    readonly noTools: "No tool calls retained.";
+    readonly arguments: "Arguments";
+    readonly result: "Result";
+    readonly loading: "Loading local conversation…";
+    readonly current: "Present-day session, not a timeline reconstruction. May include later messages and tools. Refresh explicitly for updates.";
+    readonly historical: "Historical cursor: conversation content is hidden to avoid showing future mutable text. Return to live before revealing this operation.";
+    readonly disabled: "Content is disabled. Set console.sessionHistory.contentEnabled to true in .opencode/openteam.json and restart the Console. Then reveal content here.";
+    readonly unavailable: "Conversation unavailable. Start an operator-owned local opencode serve against the same workspace and user history, configure console.sessionHistory.endpoint, then retry. No inference was requested.";
+    readonly empty: "No readable user messages, assistant output or tool calls remain in this session.";
+    readonly invalid: "This attempt has no recorded session in the selected run, or its history is incomplete.";
+    readonly unauthorized: "Conversation access denied.";
+    readonly pending: "Still streaming or unavailable.";
+    readonly compacted: "Tool result was compacted by opencode.";
+    readonly invalidEndpoint: "Expected a loopback HTTP origin without credentials, path, query or fragment.";
+    readonly readFailed: "Local session history could not be read.";
+    readonly oversized: "Conversation exceeds the local size limit (4 MiB). No content was loaded.";
+    readonly truncated: "Conversation display is truncated by local safety limits; omitted content is not empty history.";
+    readonly truncatedMarker: "\n[truncated]";
+    readonly terminalGap: "Live collection was interrupted; events during the gap are unavailable. This is not complete session history.";
+    readonly terminalTrimmed: "Older live output was discarded by the local display limit.";
+};
+//# sourceMappingURL=consoleDetail.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"consoleDetail.d.ts","sourceRoot":"","sources":["../../src/messages/consoleDetail.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB;aAChC,MAAM,EAAE,qBAAqB;aAC7B,YAAY,EAAE,6CAA6C;aAC3D,MAAM,EAAE,iBAAiB;aACzB,QAAQ,EAAE,uCAAuC;aACjD,YAAY,EAAE,qCAAqC;aACnD,mBAAmB,EAAE,8BAA8B;aACnD,OAAO,EAAE,sBAAsB;aAC/B,KAAK,EAAE,8BAA8B;aACrC,KAAK,EAAE,kCAAkC;aACzC,YAAY,EAAE,cAAc;aAC5B,MAAM,EAAE,QAAQ;aAChB,OAAO,EAAE,SAAS;aAClB,UAAU,EAAE,aAAa;aACzB,cAAc,EAAE,iBAAiB;aACjC,aAAa,EAAE,gBAAgB;aAC/B,WAAW,EAAE,cAAc;aAC3B,GAAG,EAAE,KAAK;aACV,WAAW,EAAE,cAAc;aAC3B,eAAe,EAAE,iDAAiD;aAClE,eAAe,EACb,mGAAmG;aACrG,WAAW,EACT,8GAA8G;aAChH,SAAS,EACP,iGAAiG;aACnG,YAAY,EACV,4FAA4F;aAC9F,eAAe,EACb,kGAAkG;aACpG,aAAa,EACX,sFAAsF;aACxF,gBAAgB,EACd,oGAAoG;aACtG,MAAM,EAAE,kBAAkB;aAC1B,SAAS,EAAE,yBAAyB;aACpC,KAAK,EAAE,sBAAsB;aAC7B,SAAS,EAAE,mCAAmC;aAC9C,QAAQ,EAAE,0CAA0C;aACpD,OAAO,EAAE,yBAAyB;aAClC,SAAS,EAAE,WAAW;aACtB,MAAM,EAAE,QAAQ;aAChB,OAAO,EAAE,6BAA6B;aACtC,OAAO,EACL,2HAA2H;aAC7H,UAAU,EACR,yIAAyI;aAC3I,QAAQ,EACN,sJAAsJ;aACxJ,WAAW,EACT,wMAAwM;aAC1M,KAAK,EACH,mFAAmF;aACrF,OAAO,EACL,yFAAyF;aAC3F,YAAY,EAAE,6BAA6B;aAC3C,OAAO,EAAE,iCAAiC;aAC1C,SAAS,EAAE,wCAAwC;aACnD,eAAe,EACb,+EAA+E;aACjF,UAAU,EAAE,0CAA0C;aACtD,SAAS,EACP,2EAA2E;aAC7E,SAAS,EACP,iGAAiG;aACnG,eAAe,EAAE,eAAe;aAChC,WAAW,EACT,+GAA+G;aACjH,eAAe,EACb,6DAA6D;CACvD,CAAC"}

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"}