lorenz 0.1.0

package/packages/worker-sdk/dist/fake.js

@@ -0,0 +1,142 @@
+import { defaultWorkerDriverRegistry } from "./registry.js";
+const KIND = "fake";
+const CAPABILITIES = {
+    sshAddressable: false,
+    ephemeral: false,
+    usesLedger: false,
+};
+/**
+ * An in-memory {@link WorkerDriver} used by the always-on test layer and the
+ * memory-tracker e2e demo, and the SDK's reference implementation of the
+ * driver contract. It owns no real machines and touches no disk: every
+ * operation mutates a `Map<workerId, WorkerDescriptor>` and the yielded `workerHost`
+ * is a synthetic `fake://worker-<workerId>` address. Determinism comes from the
+ * injected clock (so `createdAtMs` is reproducible), and failure can be
+ * injected per-worker so tests can exercise probe/provision/destroy faults and
+ * the conformance suite's unreachable-worker case.
+ */
+export class FakeWorkerDriver {
+    deps;
+    kind = KIND;
+    capabilities = CAPABILITIES;
+    // The live inventory: provisioned-minus-destroyed, keyed on the pool's
+    // idempotency key so `provision` is idempotent on `workerId`.
+    workers = new Map();
+    // Per-worker failure injections. `probeFailures` flips `probe` to `{ ok: false }`;
+    // `provisionFailures`/`destroyFailures` reject the respective call.
+    probeFailures = new Map();
+    provisionFailures = new Map();
+    destroyFailures = new Map();
+    // A write counter that proves the driver never touched the disk. It is
+    // structurally pinned at 0 (the driver holds only in-memory state), so a
+    // test can assert ZERO fs I/O by reading `fsWriteCount`.
+    writes = 0;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** Number of fs writes performed (always 0; the driver is purely in-memory). */
+    get fsWriteCount() {
+        return this.writes;
+    }
+    /**
+     * Provisions (or re-adopts) a worker for `req.workerId`. Idempotent on `workerId`: a
+     * second call returns the SAME descriptor without creating a duplicate. The
+     * descriptor is stamped from the injected clock so its `createdAtMs` is
+     * deterministic.
+     */
+    async provision(req) {
+        const injected = this.provisionFailures.get(req.workerId);
+        if (injected !== undefined) {
+            return Promise.reject(new Error(injected));
+        }
+        const existing = this.workers.get(req.workerId);
+        if (existing) {
+            return Promise.resolve(existing);
+        }
+        const workerHost = `fake://worker-${req.workerId}`;
+        const descriptor = {
+            workerId: req.workerId,
+            workerHost,
+            driverRef: workerHost,
+            createdAtMs: this.deps.clock.now().getTime(),
+            labels: [...req.labels],
+            metadata: {},
+        };
+        this.workers.set(req.workerId, descriptor);
+        return Promise.resolve(descriptor);
+    }
+    /**
+     * Reports the worker healthy unless a probe failure was injected for its
+     * `workerId`. An unknown/already-destroyed worker is reported `ok: false` rather
+     * than throwing (mirroring a real probe against a gone machine).
+     */
+    async probe(worker, _opts) {
+        const injected = this.probeFailures.get(worker.workerId);
+        if (injected !== undefined) {
+            return Promise.resolve({ ok: false, reason: injected });
+        }
+        if (!this.workers.has(worker.workerId)) {
+            return Promise.resolve({ ok: false, reason: "fake_worker_not_found" });
+        }
+        return Promise.resolve({ ok: true });
+    }
+    /**
+     * Destroys a worker. Idempotent and tolerant of an already-gone (or
+     * never-provisioned) worker. Rejects only when a destroy failure was injected
+     * for the worker, leaving the worker in place so the caller can retry.
+     */
+    async destroy(worker, _opts) {
+        const injected = this.destroyFailures.get(worker.workerId);
+        if (injected !== undefined) {
+            return Promise.reject(new Error(injected));
+        }
+        this.workers.delete(worker.workerId);
+        return Promise.resolve();
+    }
+    /** Returns the live inventory (provisioned-minus-destroyed). */
+    async list() {
+        return Promise.resolve([...this.workers.values()]);
+    }
+    /** Injects a probe failure so `probe` returns `{ ok: false, reason }`. */
+    injectProbeFailure(workerId, reason) {
+        this.probeFailures.set(workerId, reason);
+    }
+    /** Clears a previously injected probe failure so the worker probes healthy again. */
+    clearProbeFailure(workerId) {
+        this.probeFailures.delete(workerId);
+    }
+    /** Injects a provision failure so `provision` rejects with `reason`. */
+    injectProvisionFailure(workerId, reason) {
+        this.provisionFailures.set(workerId, reason);
+    }
+    /** Clears a previously injected provision failure. */
+    clearProvisionFailure(workerId) {
+        this.provisionFailures.delete(workerId);
+    }
+    /** Injects a destroy failure so `destroy` rejects with `reason`. */
+    injectDestroyFailure(workerId, reason) {
+        this.destroyFailures.set(workerId, reason);
+    }
+    /** Clears a previously injected destroy failure. */
+    clearDestroyFailure(workerId) {
+        this.destroyFailures.delete(workerId);
+    }
+}
+/** The registered `fake` factory: constructs a fresh in-memory driver per pool. */
+export const fakeWorkerDriverFactory = {
+    kind: KIND,
+    create: (_options, deps) => new FakeWorkerDriver(deps),
+};
+/**
+ * Registers the `fake` driver. The SDK ships this reference driver (rather
+ * than an extension) so engine and extension test suites alike can exercise
+ * the pool without real machines; the composition root registers it next to
+ * the real driver extensions.
+ */
+export function registerFakeWorkerDriver(registries = {}) {
+    const drivers = registries.workerDrivers ?? defaultWorkerDriverRegistry;
+    if (drivers.get(KIND) === undefined) {
+        drivers.register(fakeWorkerDriverFactory);
+    }
+}
+//# sourceMappingURL=fake.js.map

package/packages/worker-sdk/dist/fake.js.map

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

package/packages/worker-sdk/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { POOL_OWNED_LABEL, type WorkerDescriptor, type WorkerDriver, type WorkerDriverFactory, type WorkerHealth, type DriverCapabilities, type DriverDeps, type ProvisionRequest, type SshRunOptions, type SshRunResult, type SshRunner, type TeardownReason, } from "./types.js";
+export { WorkerDriverRegistry, defaultWorkerDriverRegistry } from "./registry.js";
+export { WORKER_DRIVER_SDK_VERSION, assertWorkerDriverModule, defineWorkerDriver, type WorkerDriverModule, } from "./module.js";
+export { FakeWorkerDriver, fakeWorkerDriverFactory, registerFakeWorkerDriver } from "./fake.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/worker-sdk/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,gBAAgB,EAChB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,cAAc,GACpB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAElF,OAAO,EACL,yBAAyB,EACzB,wBAAwB,EACxB,kBAAkB,EAClB,KAAK,kBAAkB,GACxB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC"}

package/packages/worker-sdk/dist/index.js

@@ -0,0 +1,10 @@
+// The worker SDK: the contract a worker backend implements to join the warm
+// worker pool, the registry the composition root wires it into, and the
+// in-memory reference driver. The conformance kit lives behind the
+// `@lorenz/worker-sdk/conformance` subpath so the runtime barrel never pulls
+// vitest.
+export { POOL_OWNED_LABEL, } from "./types.js";
+export { WorkerDriverRegistry, defaultWorkerDriverRegistry } from "./registry.js";
+export { WORKER_DRIVER_SDK_VERSION, assertWorkerDriverModule, defineWorkerDriver, } from "./module.js";
+export { FakeWorkerDriver, fakeWorkerDriverFactory, registerFakeWorkerDriver } from "./fake.js";
+//# sourceMappingURL=index.js.map

package/packages/worker-sdk/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,wEAAwE;AACxE,mEAAmE;AACnE,6EAA6E;AAC7E,UAAU;AAEV,OAAO,EACL,gBAAgB,GAYjB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAElF,OAAO,EACL,yBAAyB,EACzB,wBAAwB,EACxB,kBAAkB,GAEnB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC"}

package/packages/worker-sdk/dist/module.d.ts

@@ -0,0 +1,46 @@
+import type { WorkerDriverFactory } from "./types.js";
+/**
+ * The worker-driver SDK version this build of the engine speaks. Out-of-tree
+ * driver modules declare the version they target via
+ * {@link WorkerDriverModule.sdkVersion}; the loader rejects a mismatch before the
+ * module ever reaches the registry. Major-only: additive, backwards-compatible
+ * SDK changes never bump it.
+ */
+export declare const WORKER_DRIVER_SDK_VERSION = 1;
+/**
+ * The unit an OUT-OF-TREE worker-driver module exports: a {@link WorkerDriverFactory}
+ * carrying the SDK version it targets. In-repo extensions register factories
+ * directly (the composition root vouches for them); a dynamically imported
+ * module instead crosses a version boundary the daemon cannot type-check, so
+ * the explicit `sdkVersion` handshake stands in for the compiler.
+ */
+export interface WorkerDriverModule extends WorkerDriverFactory {
+    readonly sdkVersion: number;
+}
+/**
+ * Authoring sugar for out-of-tree driver modules: shape-asserts the module at
+ * definition time (so a typo fails in the author's tests, not the operator's
+ * daemon) and returns it unchanged. Usage:
+ *
+ * ```ts
+ * export default defineWorkerDriver({
+ *   kind: "acme",
+ *   sdkVersion: 1,
+ *   create: (options, deps) => new AcmeWorkerDriver(options, deps),
+ * });
+ * ```
+ */
+export declare function defineWorkerDriver(module: WorkerDriverModule): WorkerDriverModule;
+/**
+ * Structural check + version handshake for a dynamically loaded worker-driver
+ * module. `source` names where the value came from (a module specifier, or
+ * `defineWorkerDriver` at authoring time) so every error is actionable. Throws:
+ *
+ * - `worker_pool_driver_module_invalid: <source> ...` when the value is not an
+ *   object, `kind` is not a non-empty string, `create` is not a function, or
+ *   `sdkVersion` is not a number;
+ * - `worker_pool_driver_sdk_mismatch: <source> targets SDK v<n>, this build
+ *   supports v<WORKER_DRIVER_SDK_VERSION>` when the declared version differs.
+ */
+export declare function assertWorkerDriverModule(value: unknown, source: string): asserts value is WorkerDriverModule;
+//# sourceMappingURL=module.d.ts.map

package/packages/worker-sdk/dist/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C;;;;;;GAMG;AACH,MAAM,WAAW,kBAAmB,SAAQ,mBAAmB;IAC7D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,GAAG,kBAAkB,CAGjF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,KAAK,IAAI,kBAAkB,CA+BrC"}

package/packages/worker-sdk/dist/module.js

@@ -0,0 +1,59 @@
+/**
+ * The worker-driver SDK version this build of the engine speaks. Out-of-tree
+ * driver modules declare the version they target via
+ * {@link WorkerDriverModule.sdkVersion}; the loader rejects a mismatch before the
+ * module ever reaches the registry. Major-only: additive, backwards-compatible
+ * SDK changes never bump it.
+ */
+export const WORKER_DRIVER_SDK_VERSION = 1;
+/**
+ * Authoring sugar for out-of-tree driver modules: shape-asserts the module at
+ * definition time (so a typo fails in the author's tests, not the operator's
+ * daemon) and returns it unchanged. Usage:
+ *
+ * ```ts
+ * export default defineWorkerDriver({
+ *   kind: "acme",
+ *   sdkVersion: 1,
+ *   create: (options, deps) => new AcmeWorkerDriver(options, deps),
+ * });
+ * ```
+ */
+export function defineWorkerDriver(module) {
+    assertWorkerDriverModule(module, "defineWorkerDriver");
+    return module;
+}
+/**
+ * Structural check + version handshake for a dynamically loaded worker-driver
+ * module. `source` names where the value came from (a module specifier, or
+ * `defineWorkerDriver` at authoring time) so every error is actionable. Throws:
+ *
+ * - `worker_pool_driver_module_invalid: <source> ...` when the value is not an
+ *   object, `kind` is not a non-empty string, `create` is not a function, or
+ *   `sdkVersion` is not a number;
+ * - `worker_pool_driver_sdk_mismatch: <source> targets SDK v<n>, this build
+ *   supports v<WORKER_DRIVER_SDK_VERSION>` when the declared version differs.
+ */
+export function assertWorkerDriverModule(value, source) {
+    if (typeof value !== "object" || value === null) {
+        throw new Error(`worker_pool_driver_module_invalid: ${source} did not yield a worker driver module object ` +
+            `(got ${value === null ? "null" : typeof value}); export defineWorkerDriver({ kind, sdkVersion, create }) ` +
+            `as the default export or a named export`);
+    }
+    const candidate = value;
+    if (typeof candidate.kind !== "string" || candidate.kind.trim() === "") {
+        throw new Error(`worker_pool_driver_module_invalid: ${source} is missing a non-empty string \`kind\``);
+    }
+    if (typeof candidate.create !== "function") {
+        throw new Error(`worker_pool_driver_module_invalid: ${source} (kind: ${candidate.kind}) is missing a \`create(options, deps)\` function`);
+    }
+    if (typeof candidate.sdkVersion !== "number") {
+        throw new Error(`worker_pool_driver_module_invalid: ${source} (kind: ${candidate.kind}) is missing a numeric \`sdkVersion\` ` +
+            `(declare sdkVersion: ${WORKER_DRIVER_SDK_VERSION})`);
+    }
+    if (candidate.sdkVersion !== WORKER_DRIVER_SDK_VERSION) {
+        throw new Error(`worker_pool_driver_sdk_mismatch: ${source} targets SDK v${candidate.sdkVersion}, ` +
+            `this build supports v${WORKER_DRIVER_SDK_VERSION}`);
+    }
+}
+//# sourceMappingURL=module.js.map

package/packages/worker-sdk/dist/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC;AAa3C;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAA0B;IAC3D,wBAAwB,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IACvD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,wBAAwB,CACtC,KAAc,EACd,MAAc;IAEd,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAChD,MAAM,IAAI,KAAK,CACb,sCAAsC,MAAM,+CAA+C;YACzF,QAAQ,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,KAAK,6DAA6D;YAC3G,yCAAyC,CAC5C,CAAC;IACJ,CAAC;IACD,MAAM,SAAS,GAAG,KAAoC,CAAC;IACvD,IAAI,OAAO,SAAS,CAAC,IAAI,KAAK,QAAQ,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QACvE,MAAM,IAAI,KAAK,CACb,sCAAsC,MAAM,yCAAyC,CACtF,CAAC;IACJ,CAAC;IACD,IAAI,OAAO,SAAS,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;QAC3C,MAAM,IAAI,KAAK,CACb,sCAAsC,MAAM,WAAW,SAAS,CAAC,IAAI,mDAAmD,CACzH,CAAC;IACJ,CAAC;IACD,IAAI,OAAO,SAAS,CAAC,UAAU,KAAK,QAAQ,EAAE,CAAC;QAC7C,MAAM,IAAI,KAAK,CACb,sCAAsC,MAAM,WAAW,SAAS,CAAC,IAAI,wCAAwC;YAC3G,wBAAwB,yBAAyB,GAAG,CACvD,CAAC;IACJ,CAAC;IACD,IAAI,SAAS,CAAC,UAAU,KAAK,yBAAyB,EAAE,CAAC;QACvD,MAAM,IAAI,KAAK,CACb,oCAAoC,MAAM,iBAAiB,SAAS,CAAC,UAAU,IAAI;YACjF,wBAAwB,yBAAyB,EAAE,CACtD,CAAC;IACJ,CAAC;AACH,CAAC"}

package/packages/worker-sdk/dist/registry.d.ts

@@ -0,0 +1,24 @@
+import type { WorkerDriverFactory } from "./types.js";
+/**
+ * Lookup table of {@link WorkerDriverFactory}s keyed by `worker.worker_pool.driver`.
+ * The pool resolves the configured kind through a registry instead of
+ * hardcoding backends, so the set of supported worker drivers is decided by
+ * whoever composes the application.
+ */
+export declare class WorkerDriverRegistry {
+    private readonly factories;
+    /** Register a factory. Throws when a different factory already claims the kind. */
+    register(factory: WorkerDriverFactory): void;
+    get(kind: string | undefined): WorkerDriverFactory | undefined;
+    /** Like {@link get} but throws a config-style error listing the known kinds. */
+    require(kind: string | undefined): WorkerDriverFactory;
+    kinds(): string[];
+}
+/**
+ * Process-wide registry used as the default by the pool and the CLI. The
+ * composition root (the CLI entrypoint, or a test) registers drivers here;
+ * library code only reads from it. Call sites that need isolation can
+ * construct their own {@link WorkerDriverRegistry} and pass it explicitly.
+ */
+export declare const defaultWorkerDriverRegistry: WorkerDriverRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/packages/worker-sdk/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;GAKG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0C;IAEpE,mFAAmF;IACnF,QAAQ,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI;IAU5C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,mBAAmB,GAAG,SAAS;IAI9D,gFAAgF;IAChF,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,mBAAmB;IAgBtD,KAAK,IAAI,MAAM,EAAE;CAGlB;AAED;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,sBAA6B,CAAC"}

package/packages/worker-sdk/dist/registry.js

@@ -0,0 +1,49 @@
+/**
+ * Lookup table of {@link WorkerDriverFactory}s keyed by `worker.worker_pool.driver`.
+ * The pool resolves the configured kind through a registry instead of
+ * hardcoding backends, so the set of supported worker drivers is decided by
+ * whoever composes the application.
+ */
+export class WorkerDriverRegistry {
+    factories = new Map();
+    /** Register a factory. Throws when a different factory already claims the kind. */
+    register(factory) {
+        const kind = factory.kind.trim();
+        if (!kind)
+            throw new Error("worker driver kind must not be blank");
+        const existing = this.factories.get(kind);
+        if (existing && existing !== factory) {
+            throw new Error(`worker driver already registered for kind: ${kind}`);
+        }
+        this.factories.set(kind, factory);
+    }
+    get(kind) {
+        return kind === undefined ? undefined : this.factories.get(kind);
+    }
+    /** Like {@link get} but throws a config-style error listing the known kinds. */
+    require(kind) {
+        if (kind === undefined || kind === null || kind === "") {
+            throw new Error("worker.worker_pool.driver is required");
+        }
+        const factory = this.factories.get(kind);
+        if (!factory) {
+            const known = this.kinds();
+            const hint = known.length > 0
+                ? ` (known kinds: ${known.join(", ")})`
+                : " (no worker drivers registered - register worker driver extensions at the composition root)";
+            throw new Error(`worker_pool_driver_unavailable: ${kind}${hint}`);
+        }
+        return factory;
+    }
+    kinds() {
+        return [...this.factories.keys()].sort();
+    }
+}
+/**
+ * Process-wide registry used as the default by the pool and the CLI. The
+ * composition root (the CLI entrypoint, or a test) registers drivers here;
+ * library code only reads from it. Call sites that need isolation can
+ * construct their own {@link WorkerDriverRegistry} and pass it explicitly.
+ */
+export const defaultWorkerDriverRegistry = new WorkerDriverRegistry();
+//# sourceMappingURL=registry.js.map

package/packages/worker-sdk/dist/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,OAAO,oBAAoB;IACd,SAAS,GAAG,IAAI,GAAG,EAA+B,CAAC;IAEpE,mFAAmF;IACnF,QAAQ,CAAC,OAA4B;QACnC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QACjC,IAAI,CAAC,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;QACnE,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC1C,IAAI,QAAQ,IAAI,QAAQ,KAAK,OAAO,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CAAC,8CAA8C,IAAI,EAAE,CAAC,CAAC;QACxE,CAAC;QACD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACpC,CAAC;IAED,GAAG,CAAC,IAAwB;QAC1B,OAAO,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACnE,CAAC;IAED,gFAAgF;IAChF,OAAO,CAAC,IAAwB;QAC9B,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;YACvD,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;QAC3D,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACzC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;YAC3B,MAAM,IAAI,GACR,KAAK,CAAC,MAAM,GAAG,CAAC;gBACd,CAAC,CAAC,kBAAkB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG;gBACvC,CAAC,CAAC,6FAA6F,CAAC;YACpG,MAAM,IAAI,KAAK,CAAC,mCAAmC,IAAI,GAAG,IAAI,EAAE,CAAC,CAAC;QACpE,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,KAAK;QACH,OAAO,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;IAC3C,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,IAAI,oBAAoB,EAAE,CAAC"}

package/packages/worker-sdk/dist/types.d.ts

@@ -0,0 +1,138 @@
+import type { ClockPort } from "@lorenz/domain";
+/**
+ * The worker driver contract: everything a third party needs to ship a new worker
+ * backend (their own cloud, their own VM fleet) as an extension, without
+ * touching the pool engine. A driver provisions, probes, destroys, and lists
+ * SSH-addressable workers behind one interface; the warm pool in
+ * `@lorenz/worker-pool` owns every lifecycle decision (leasing, reaping,
+ * spend, crash recovery) and only ever calls these four operations.
+ *
+ * This module is dependency-light by design: it pulls `ClockPort` from
+ * `@lorenz/domain` only, so extensions implementing a driver depend on the
+ * SDK layer alone.
+ */
+/**
+ * The label every pool-owned worker carries so a `list()` reconcile can re-adopt
+ * or destroy ONLY workers the pool created (never an unlabeled foreign
+ * instance). The pool stamps this on every provision request, and every
+ * driver's `list()` MUST surface it on the descriptors it returns (the pool's
+ * ownership gate keys on it).
+ */
+export declare const POOL_OWNED_LABEL = "symphony.pool=worker-pool";
+/**
+ * Why a worker is being torn down. Drives driver `destroy` and the pool's
+ * ledger/spend bookkeeping; never runs workspace hooks (the runner owns
+ * workspace lifecycle).
+ */
+export type TeardownReason = "ttl" | "idle" | "shrink" | "unhealthy" | "failed" | "drain" | "orphan";
+/**
+ * Driver-reported health of a single worker. The probe is a cheap readiness
+ * check (e.g. `printf ready` over SSH), not a workspace/hook operation.
+ */
+export type WorkerHealth = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Static capabilities of a driver backend. `usesLedger` gates the write-ahead
+ * ledger (cloud-only); `sshAddressable` records that the yielded `workerHost`
+ * is an SSH destination; `ephemeral` records that workers are disposable
+ * machines.
+ */
+export interface DriverCapabilities {
+    sshAddressable: boolean;
+    ephemeral: boolean;
+    usesLedger: boolean;
+}
+/**
+ * A provisioned worker. `workerHost` is the SSH-addressable string threaded
+ * end-to-end by the orchestrator/runner. `driverRef` is the backend's own
+ * handle (e.g. a machine id) used for `destroy`/`list` reconcile. `labels`
+ * tag pool-owned survivors so a `list()` reconcile can re-adopt them.
+ */
+export interface WorkerDescriptor {
+    workerId: string;
+    workerHost: string;
+    driverRef: string;
+    createdAtMs: number;
+    labels: ReadonlyArray<string>;
+    metadata: Record<string, unknown>;
+}
+/**
+ * Request to provision one worker. `workerId` is the pool's idempotency key (a
+ * driver must return the same worker for the same `workerId`). `affinityKey` carries
+ * a prior `workerHost` so a retry can re-land on the same machine. `labels`
+ * are stamped on the worker for reconcile. `driverOptions` is the operator's selected
+ * `workers.<name>` profile, minus `driver`, passed through verbatim.
+ */
+export interface ProvisionRequest {
+    workerId: string;
+    affinityKey?: string | null;
+    labels: ReadonlyArray<string>;
+    timeoutMs: number;
+    signal?: AbortSignal;
+    driverOptions?: Record<string, unknown>;
+}
+/**
+ * A swappable backend that provisions, probes, destroys, and lists workers
+ * behind one interface. Every implementation must be idempotent on `workerId`
+ * for `provision` and idempotent for `destroy` (a second destroy of a gone
+ * machine is tolerated, never an error).
+ */
+export interface WorkerDriver {
+    readonly kind: string;
+    provision(req: ProvisionRequest): Promise<WorkerDescriptor>;
+    probe(worker: WorkerDescriptor, opts: {
+        timeoutMs: number;
+        signal?: AbortSignal;
+    }): Promise<WorkerHealth>;
+    destroy(worker: WorkerDescriptor, opts: {
+        timeoutMs: number;
+        reason: TeardownReason;
+    }): Promise<void>;
+    list(): Promise<WorkerDescriptor[]>;
+    readonly capabilities: DriverCapabilities;
+}
+/**
+ * Structural mirror of the engine's ssh runner so drivers can probe workers over
+ * SSH without depending on the engine ssh package. The pool injects the real
+ * implementation through {@link DriverDeps}; tests inject fakes.
+ */
+export interface SshRunOptions {
+    timeoutMs?: number | undefined;
+    stderrToStdout?: boolean | undefined;
+    abortSignal?: AbortSignal | undefined;
+}
+export interface SshRunResult {
+    stdout: string;
+    stderr: string;
+    status: number;
+}
+export type SshRunner = (destination: string, command: string, options?: SshRunOptions) => Promise<SshRunResult>;
+/**
+ * Dependencies a driver factory receives from the pool. Deliberately excludes
+ * any workspace or hook deps: drivers manage worker lifecycle only. Cloud
+ * transports the engine does not provide (e.g. an E2B client or Modal
+ * transport) are closed over by the extension's registration, never threaded
+ * through these deps.
+ */
+export interface DriverDeps {
+    clock: ClockPort;
+    logEvent: (event: Record<string, unknown>) => void;
+    runSsh: SshRunner;
+}
+/**
+ * The unit a worker-driver extension registers: a named constructor for its
+ * {@link WorkerDriver}. `create` receives the selected `workers.<name>` profile
+ * options verbatim (never the full pool settings, so
+ * the SDK surface stays stable) and validates them itself, throwing an
+ * actionable error at pool construction when they are unusable - the same
+ * fail-loud startup point as an unregistered kind.
+ */
+export interface WorkerDriverFactory {
+    readonly kind: string;
+    create(options: Readonly<Record<string, unknown>>, deps: DriverDeps): WorkerDriver;
+}
+//# sourceMappingURL=types.d.ts.map

package/packages/worker-sdk/dist/types.d.ts.map

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

package/packages/worker-sdk/dist/types.js

@@ -0,0 +1,21 @@
+/**
+ * The worker driver contract: everything a third party needs to ship a new worker
+ * backend (their own cloud, their own VM fleet) as an extension, without
+ * touching the pool engine. A driver provisions, probes, destroys, and lists
+ * SSH-addressable workers behind one interface; the warm pool in
+ * `@lorenz/worker-pool` owns every lifecycle decision (leasing, reaping,
+ * spend, crash recovery) and only ever calls these four operations.
+ *
+ * This module is dependency-light by design: it pulls `ClockPort` from
+ * `@lorenz/domain` only, so extensions implementing a driver depend on the
+ * SDK layer alone.
+ */
+/**
+ * The label every pool-owned worker carries so a `list()` reconcile can re-adopt
+ * or destroy ONLY workers the pool created (never an unlabeled foreign
+ * instance). The pool stamps this on every provision request, and every
+ * driver's `list()` MUST surface it on the descriptors it returns (the pool's
+ * ownership gate keys on it).
+ */
+export const POOL_OWNED_LABEL = "symphony.pool=worker-pool";
+//# sourceMappingURL=types.js.map

package/packages/worker-sdk/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AAEH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,2BAA2B,CAAC"}

package/packages/worker-sdk/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@lorenz/worker-sdk",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./conformance": "./dist/conformance.js"
+  },
+  "dependencies": {
+    "@lorenz/domain": "file:../domain"
+  }
+}

package/packages/workflow/dist/index.d.ts

@@ -0,0 +1,33 @@
+import { type ParsedPromptTemplate, type WorkflowContentStamp, type WorkflowDefinition } from "@lorenz/domain";
+import type { DefaultSettingsOptions } from "@lorenz/config";
+import type { AgentExecutorRegistry } from "@lorenz/agent-sdk";
+import type { TrackerRegistry } from "@lorenz/tracker-sdk";
+type WorkflowLoadOptions = DefaultSettingsOptions & {
+    cwd?: string | undefined;
+    /**
+     * Tracker providers consulted while parsing the `tracker:` config section. The
+     * composition root passes its populated registry so provider option parsing, aliases,
+     * and env fallbacks apply; when omitted, the process-wide default registry is used.
+     */
+    trackers?: TrackerRegistry | undefined;
+    /**
+     * Executor providers consulted while parsing `agents.<kind>` config records, the same
+     * way `trackers` backs the `tracker:` section; when omitted, the process-wide default
+     * registry is used.
+     */
+    executors?: AgentExecutorRegistry | undefined;
+};
+export declare const defaultPromptTemplate = "You are working on an issue from the configured tracker.\n\nIdentifier: {{ issue.identifier }}\nTitle: {{ issue.title }}\n\nBody:\n{% if issue.description %}\n{{ issue.description }}\n{% else %}\nNo description provided.\n{% endif %}\n";
+export declare function workflowFilePath(env?: NodeJS.ProcessEnv, cwd?: string): string;
+export declare function loadWorkflow(workflowPath?: string, env?: NodeJS.ProcessEnv, defaults?: WorkflowLoadOptions): Promise<WorkflowDefinition>;
+export declare function currentWorkflowStamp(workflowPath: string): Promise<WorkflowContentStamp>;
+export declare function workflowFileChanged(workflow: WorkflowDefinition): Promise<boolean>;
+export declare function workflowStampsEqual(left: WorkflowContentStamp | undefined, right: WorkflowContentStamp | undefined): boolean;
+export declare function parseWorkflowContent(content: string): {
+    config: Record<string, unknown>;
+    body: string;
+};
+export declare function effectivePromptTemplate(promptTemplate: string): string;
+export declare function parsePromptTemplate(promptTemplate: string): ParsedPromptTemplate;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/packages/workflow/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACxB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,KAAK,mBAAmB,GAAG,sBAAsB,GAAG;IAClD,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC;IACvC;;;;OAIG;IACH,SAAS,CAAC,EAAE,qBAAqB,GAAG,SAAS,CAAC;CAC/C,CAAC;AAOF,eAAO,MAAM,qBAAqB,gPAWjC,CAAC;AAEF,wBAAgB,gBAAgB,CAC9B,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,GAAG,SAAgB,GAClB,MAAM,CAIR;AAED,wBAAsB,YAAY,CAChC,YAAY,CAAC,EAAE,MAAM,EACrB,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,QAAQ,GAAE,mBAAwB,GACjC,OAAO,CAAC,kBAAkB,CAAC,CAoB7B;AAED,wBAAsB,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAQ9F;AAED,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC,CAGxF;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,oBAAoB,GAAG,SAAS,EACtC,KAAK,EAAE,oBAAoB,GAAG,SAAS,GACtC,OAAO,CAQT;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG;IACrD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;CACd,CAyBA;AAED,wBAAgB,uBAAuB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED,wBAAgB,mBAAmB,CAAC,cAAc,EAAE,MAAM,GAAG,oBAAoB,CAUhF"}