@jmanuelcorral/openteam 0.18.1 → 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/mcp/teamMemory.d.ts

@@ -32,8 +32,8 @@ export type CostSummary = {
     sessions: number;
     messageCount: number;
     realCostUSD: number;
-    estimatedCostUSD: number;
-    estimatedSavingsUSD: number;
+    estimatedCostUSD: number | null;
+    estimatedSavingsUSD: number | null;
     tokensIn: number;
     tokensOut: number;
 };

package/dist/mcp/teamMemory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"teamMemory.d.ts","sourceRoot":"","sources":["../../src/mcp/teamMemory.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,cAAc,EACpB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,MAAM,EAAE,WAAW,CAAC;IACpB,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,QAAQ,EAAE,WAAW,EAAE,CAAC;CACzB,CAAC;AAEF,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,GAAG,UAAU,CAQ5E;AASD,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,8EAA8E;AAC9E,wBAAgB,cAAc,CAC5B,MAAM,EAAE,UAAU,EAClB,KAAK,GAAE,aAAkB,GACxB,YAAY,EAAE,CAWhB;AAED,+DAA+D;AAC/D,wBAAgB,aAAa,CAC3B,MAAM,EAAE,UAAU,EAClB,KAAK,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC7B,WAAW,EAAE,CAEf;AAED,iDAAiD;AACjD,wBAAgB,aAAa,CAC3B,MAAM,EAAE,UAAU,EAClB,KAAK,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC7B,cAAc,EAAE,CAElB;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC;IACzB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,iFAAiF;AACjF,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,GAAG,WAAW,CAW3D"}
+{"version":3,"file":"teamMemory.d.ts","sourceRoot":"","sources":["../../src/mcp/teamMemory.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,cAAc,EACpB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,MAAM,EAAE,WAAW,CAAC;IACpB,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,QAAQ,EAAE,WAAW,EAAE,CAAC;CACzB,CAAC;AAEF,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,GAAG,UAAU,CAQ5E;AASD,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,8EAA8E;AAC9E,wBAAgB,cAAc,CAC5B,MAAM,EAAE,UAAU,EAClB,KAAK,GAAE,aAAkB,GACxB,YAAY,EAAE,CAWhB;AAED,+DAA+D;AAC/D,wBAAgB,aAAa,CAC3B,MAAM,EAAE,UAAU,EAClB,KAAK,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC7B,WAAW,EAAE,CAEf;AAED,iDAAiD;AACjD,wBAAgB,aAAa,CAC3B,MAAM,EAAE,UAAU,EAClB,KAAK,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC7B,cAAc,EAAE,CAElB;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,iFAAiF;AACjF,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,GAAG,WAAW,CAW3D"}

package/dist/messages/commands.d.ts

@@ -45,32 +45,32 @@ export declare const baselineMessages: {
 /** Messages for `openteam local`. */
 export declare const localMessages: {
     readonly help: {
-        readonly status: "  openteam local status             Show the routing mode (local-first / local-only / frontier-only)";
-        readonly off: "  openteam local off                Use frontier models only (no local runtime)";
-        readonly only: "  openteam local only               Use local models only (never frontier)";
-        readonly on: "  openteam local on                 Re-enable local-first routing";
+        readonly status: "  openteam local status             Show the execution mode (local / frontier / mixed)";
+        readonly off: "  openteam local off                Use frontier models only";
+        readonly only: "  openteam local only               Use local models only";
+        readonly on: "  openteam local on                 Enable mixed local/frontier execution";
     };
     readonly noRuntimes: "none";
-    readonly modeFrontierOnly: "frontier-only (frontierOnly)";
-    readonly modeLocalOnly: "local-only (localOnly)";
-    readonly modeLocalFirst: "local-first";
+    readonly modeFrontier: "frontier";
+    readonly modeLocal: "local";
+    readonly modeMixed: "mixed";
     readonly summary: (params: {
         mode: string;
-        frontierOnly: boolean;
-        localOnly: boolean;
-        privacy: string;
         runtimes: string;
     }) => string[];
-    readonly frontierOnlyNoChange: "No change: already in frontier-only mode.";
-    readonly privacyAdjustedNote: " Privacy adjusted to 'consentBeforeFrontier' (forceLocalOnSensitive requires a local runtime).";
-    readonly frontierOnlyEnabled: "Frontier-only mode enabled (frontierOnly=true, localOnly=false).";
-    readonly localOnlyNoRuntimes: "Cannot enable local-only mode: no enabled local runtime is configured. Run 'openteam setup' or enable a local runtime in .opencode/openteam.json first.";
-    readonly localOnlyNoChange: "No change: already in local-only mode.";
-    readonly localOnlyEnabled: "Local-only mode enabled (localOnly=true, frontierOnly=false).";
-    readonly localFirstNoChange: "No change: local-first routing is already active.";
-    readonly localFirstReEnabled: "Local-first routing re-enabled (frontierOnly=false, localOnly=false). Make sure a local runtime is reachable.";
+    readonly frontierOnlyNoChange: "No change: execution mode is already frontier.";
+    readonly frontierOnlyEnabled: "Frontier execution enabled.";
+    readonly localOnlyNoRuntimes: "Cannot enable local execution: no enabled local runtime is configured. Run 'openteam setup' or enable a local runtime in .opencode/openteam.json first.";
+    readonly localOnlyNoChange: "No change: execution mode is already local.";
+    readonly localOnlyEnabled: "Local execution enabled.";
+    readonly localFirstNoChange: "No change: execution mode is already mixed.";
+    readonly localFirstReEnabled: "Mixed local/frontier execution enabled. Make sure each configured provider is reachable.";
     readonly unknownSubcommand: (subcommand: string, help: string) => string;
 };
+/** Messages for `openteam yolo`. */
+export declare const yoloMessages: {
+    readonly updated: (path: string, status: string, agentNote: string) => string;
+};
 /** Messages for the frontier catalog rendered during `init`. */
 export declare const frontierCatalogMessages: {
     readonly free: "free";
@@ -93,14 +93,9 @@ export declare const migrateMessages: {
     readonly manualWorktreeEntry: (label: string, from: string, to: string) => string;
     readonly success: "  ✓ machine-local runtime output relocated under .opencode/openteam-local/.";
 };
-/**
- * Messages for `openteam roles init` (#206) — assisted composition of per-role
- * routing policy. The wording carries the whole point of the command: a roster
- * role with no profile is frontier-eligible, and the "local only" note a human
- * writes in the roster prose is never read because it sits outside the JSON
- * fence. Keep that consequence stated explicitly; softening it recreates the bug.
- */
+/** Messages for `openteam roles init` assisted per-role policy composition. */
 export declare const rolesInitMessages: {
+    readonly help: "  openteam roles init               Compose per-role execution, model, and fallback policy";
     readonly header: "openteam roles init:";
     readonly title: "openteam roles init";
     readonly noRoster: (path: string) => string;
@@ -108,23 +103,15 @@ export declare const rolesInitMessages: {
     readonly unparseableRoster: (path: string, error: string) => string;
     readonly unparseableRosterRemedy: "    Run `openteam doctor` for the remedy, then re-run this command.";
     readonly allProfiled: (count: number) => string;
-    readonly whyTitle: "Why you are being asked";
-    readonly why: (count: number) => string;
-    readonly policyQuestion: (roleID: string, agentName: string) => string;
-    readonly localOnlyLabel: (roleID: string, agentName: string) => string;
-    readonly localOnlyHint: "sets requiresLocalRuntime; the role fails closed when no local runtime is reachable";
-    readonly frontierOkLabel: "Local first, frontier allowed";
-    readonly frontierOkHint: "records today's implicit behaviour: cheapest-capable frontier when the task warrants it";
     readonly skipLabel: "Skip for now";
-    readonly skipHint: "leaves the role unprofiled, so it stays frontier-eligible and doctor keeps reporting it";
+    readonly skipHint: "leaves the role on its built-in or fallback policy; doctor keeps reporting the missing explicit override";
     readonly runtimeQuestion: (roleID: string) => string;
     readonly runtimeHint: "machine-local — written to the git-ignored overlay";
     readonly cancelled: (reason: string) => string;
     readonly invalidResult: (reason: string) => string;
+    readonly deprecation: (message: string) => string;
     readonly nothingWritten: (skipped: string) => string;
     readonly nothingToWriteOutro: "Nothing to write.";
-    readonly pinnedLocal: (roleIDs: string, path: string) => string;
-    readonly frontierAllowed: (roleIDs: string, path: string) => string;
     readonly runtimeBinding: (path: string) => string;
     readonly skippedSummary: (roleIDs: string) => string;
     readonly outro: "Role policy updated.";