@groundnuty/macf-core 0.2.47 → 0.2.49

package/dist/delivery/index.d.ts

@@ -0,0 +1,3 @@
+export { OutboxEntrySchema, InboxEntrySchema } from './store.js';
+export type { OutboxEntry, InboxEntry, OutboxStore, InboxStore } from './store.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/delivery/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACjE,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}

package/dist/delivery/index.js

@@ -0,0 +1,2 @@
+export { OutboxEntrySchema, InboxEntrySchema } from './store.js';
+//# sourceMappingURL=index.js.map

package/dist/delivery/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/delivery/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC"}

package/dist/delivery/store.d.ts

@@ -0,0 +1,135 @@
+/**
+ * DR-038 Decision 6 — the pluggable store INTERFACE for the effectively-once
+ * delivery layer. This is the BINDING contract: a driver (in-memory here for
+ * tests/reference, a VM disk-spool driver + a K8s PVC/broker driver owned by
+ * devops per DR-008) implements `OutboxStore` / `InboxStore` against whatever
+ * durable substrate it has. The concrete on-disk layout (filenames, jsonl vs.
+ * broker topic, etc.) is explicitly NOT part of this contract — DR-038
+ * Decision 6 is emphatic that the interface, not the file shape, is binding.
+ *
+ * HOISTED HERE (macf#741 follow-up to #738/#742) from
+ * `packages/macf-channel-server/src/delivery/store.ts` so ONE definition
+ * serves all three consumers that need it: `macf-channel-server` (the
+ * sender/receiver runtime, `outbox.ts` / `inbox.ts` / `in-memory-store.ts`),
+ * `macf` (the plugin's on-startup inbox drain, `plugin/lib/inbox-store.ts`),
+ * and devops's disk-spool driver (DR-008), which lives in a THIRD repo
+ * (`macf-devops-toolkit`) that cannot depend on either monorepo package
+ * directly — `@groundnuty/macf-core` (npm-published, already a dependency of
+ * both `macf` and `macf-channel-server`) is the one home reachable by all
+ * three. `macf-channel-server`'s local `delivery/store.ts` (the prior home
+ * of this contract) is removed; every consumer there now imports these
+ * types directly from `@groundnuty/macf-core`.
+ *
+ * Both interfaces are `Promise`-returning uniformly, even though the
+ * reference in-memory driver (`in-memory-store.ts`) and a likely disk-spool
+ * driver could be synchronous under the hood (comms-ledger.ts's
+ * `appendFileSync` precedent). This is a DELIBERATE GUESS beyond what
+ * DR-038's Decision 6 sketch pins (which shows bare `void` / `Message[]`
+ * returns) — flagged for science's review: the devops K8s PVC/broker driver
+ * (DR-008) is plausibly async (network I/O), and a uniform async contract
+ * means the runtime-agnostic `outbox.ts` / `inbox.ts` logic in this slice
+ * never needs to special-case a driver's sync-vs-async shape. If the review
+ * decides all drivers are sync-capable, this can be narrowed later without
+ * changing call sites (an async fn can always wrap a sync value).
+ *
+ * `payload` is intentionally `unknown` at the store layer — the store's job
+ * is durable persistence + dedup, not payload semantics. The effectively-once
+ * logic (`outbox.ts` / `inbox.ts`) is equally payload-agnostic; only the
+ * eventual wiring slice (notify_peer / `/notify`) will narrow `payload` to a
+ * concrete `NotifyPayload`-shaped type.
+ */
+import { z } from 'zod';
+export declare const OutboxEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    target: z.ZodString;
+    payload: z.ZodUnknown;
+    enqueuedAt: z.ZodNumber;
+    nextAttemptAt: z.ZodNumber;
+    attemptCount: z.ZodNumber;
+}, z.core.$strip>;
+export type OutboxEntry = z.infer<typeof OutboxEntrySchema>;
+export declare const InboxEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    payload: z.ZodUnknown;
+    receivedAt: z.ZodNumber;
+    processed: z.ZodBoolean;
+}, z.core.$strip>;
+export type InboxEntry = z.infer<typeof InboxEntrySchema>;
+export interface OutboxStore {
+    /**
+     * Persist a NEW entry BEFORE the first send attempt (persist-then-send,
+     * DR-038 Decision 1). Callers mint the id via `mintMessageId()` and set
+     * `attemptCount: 0` before calling this — `enqueue` is insert-only, not an
+     * upsert; retry-state mutations go through `reschedule` (below).
+     */
+    enqueue(entry: OutboxEntry): Promise<void>;
+    /**
+     * All entries not yet acked or dead-lettered — i.e. everything still
+     * awaiting delivery, regardless of whether they're currently due. This is
+     * what gets re-read on sender startup (Decision 4's restart-survival) — a
+     * fresh `outbox.ts` instance over the SAME store sees every entry a prior
+     * process instance hadn't finished with. The retry loop (`outbox.ts`)
+     * filters this list by `nextAttemptAt <= now` itself; the store does not
+     * do due-filtering (mirrors DR-038 Decision 6's `pending(): Message[]`
+     * sketch, which returns the undelivered set, not just the due subset).
+     */
+    listPending(): Promise<OutboxEntry[]>;
+    /**
+     * Reschedule an entry after a failed/timed-out send attempt: bump
+     * `nextAttemptAt` (per the backoff schedule) and `attemptCount`. This is
+     * an ADDITION beyond DR-038 Decision 6's sketch (which shows only
+     * `enqueue` / `pending` / `markAcked` / `deadLetter`) — flagged for
+     * review: the retry loop needs SOME way to durably persist backoff state
+     * so a restart resumes the correct schedule rather than restarting
+     * backoff from attempt 0 (which would race through TTL faster than
+     * intended after a crash-loop). `reschedule` is the minimal mutate-in-
+     * place primitive for that; it does not change the entry's identity, so
+     * a driver can implement it as "load, patch two fields, re-persist"
+     * against any single-entry-addressable substrate.
+     */
+    reschedule(id: string, nextAttemptAt: number, attemptCount: number): Promise<void>;
+    /** Durable-ACK path (HTTP 200 received) → remove the entry (Decision 3). */
+    markAcked(id: string): Promise<void>;
+    /**
+     * TTL-expiry path → remove from the live pending set (Decision 4). The
+     * GitHub-issue escalation itself is explicitly NOT a store concern (DR-038
+     * Decision 4: "a decision-layer action... NOT a store-driver method") —
+     * this method only handles the store-side bookkeeping; the caller
+     * (`outbox.ts`) separately invokes an `onDeadLetter` callback for the
+     * decision-layer escalation, wired by a later slice.
+     */
+    deadLetter(id: string): Promise<void>;
+}
+export interface InboxStore {
+    /**
+     * Atomically dedup-and-persist. Returns `wasNew: true` when this `id`
+     * wasn't already present (a genuinely new message, now durably persisted);
+     * `false` when it was already present (a redelivery — no-op, existing
+     * entry left untouched). MUST be a single atomic operation — DR-038
+     * Decision 6 is explicit that a separate `has()` + `persist()` would
+     * reopen the check-then-act TOCTOU this primitive exists to close.
+     */
+    persist(entry: InboxEntry): Promise<boolean>;
+    /** Existence check by id (task-specified addition beyond the DR-038 sketch). */
+    has(id: string): Promise<boolean>;
+    /** Fetch by id, or `undefined` if absent (task-specified addition). */
+    get(id: string): Promise<InboxEntry | undefined>;
+    /**
+     * Persisted-but-not-yet-processed entries — drained on-receipt AND
+     * on-startup (DR-038 Decision 5). Dedup-by-id makes the two triggers
+     * safe to overlap.
+     */
+    listUndrained(): Promise<InboxEntry[]>;
+    /**
+     * Mark an entry processed — it won't be re-drained.
+     *
+     * Forward-note (DR-038 / macf#741): today's plugin drain calls this
+     * BEFORE surfacing the entry to the operator/agent (mark-then-surface),
+     * against an in-memory reference store where the distinction is moot. Once
+     * a durable driver lands, revisit the ordering to surface-then-mark
+     * instead, so a crash between the two steps can't silently drop a message
+     * that was marked processed but never actually surfaced.
+     */
+    markProcessed(id: string): Promise<void>;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/delivery/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/delivery/store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,iBAAiB;;;;;;;iBAsB5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAM5D,eAAO,MAAM,gBAAgB;;;;;iBAS3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAM1D,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,OAAO,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3C;;;;;;;;;OASG;IACH,WAAW,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IAEtC;;;;;;;;;;;;OAYG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnF,4EAA4E;IAC5E,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAErC;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AAMD,MAAM,WAAW,UAAU;IACzB;;;;;;;OAOG;IACH,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAE7C,gFAAgF;IAChF,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAElC,uEAAuE;IACvE,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC;IAEjD;;;;OAIG;IACH,aAAa,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IAEvC;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1C"}

package/dist/delivery/store.js

@@ -0,0 +1,81 @@
+/**
+ * DR-038 Decision 6 — the pluggable store INTERFACE for the effectively-once
+ * delivery layer. This is the BINDING contract: a driver (in-memory here for
+ * tests/reference, a VM disk-spool driver + a K8s PVC/broker driver owned by
+ * devops per DR-008) implements `OutboxStore` / `InboxStore` against whatever
+ * durable substrate it has. The concrete on-disk layout (filenames, jsonl vs.
+ * broker topic, etc.) is explicitly NOT part of this contract — DR-038
+ * Decision 6 is emphatic that the interface, not the file shape, is binding.
+ *
+ * HOISTED HERE (macf#741 follow-up to #738/#742) from
+ * `packages/macf-channel-server/src/delivery/store.ts` so ONE definition
+ * serves all three consumers that need it: `macf-channel-server` (the
+ * sender/receiver runtime, `outbox.ts` / `inbox.ts` / `in-memory-store.ts`),
+ * `macf` (the plugin's on-startup inbox drain, `plugin/lib/inbox-store.ts`),
+ * and devops's disk-spool driver (DR-008), which lives in a THIRD repo
+ * (`macf-devops-toolkit`) that cannot depend on either monorepo package
+ * directly — `@groundnuty/macf-core` (npm-published, already a dependency of
+ * both `macf` and `macf-channel-server`) is the one home reachable by all
+ * three. `macf-channel-server`'s local `delivery/store.ts` (the prior home
+ * of this contract) is removed; every consumer there now imports these
+ * types directly from `@groundnuty/macf-core`.
+ *
+ * Both interfaces are `Promise`-returning uniformly, even though the
+ * reference in-memory driver (`in-memory-store.ts`) and a likely disk-spool
+ * driver could be synchronous under the hood (comms-ledger.ts's
+ * `appendFileSync` precedent). This is a DELIBERATE GUESS beyond what
+ * DR-038's Decision 6 sketch pins (which shows bare `void` / `Message[]`
+ * returns) — flagged for science's review: the devops K8s PVC/broker driver
+ * (DR-008) is plausibly async (network I/O), and a uniform async contract
+ * means the runtime-agnostic `outbox.ts` / `inbox.ts` logic in this slice
+ * never needs to special-case a driver's sync-vs-async shape. If the review
+ * decides all drivers are sync-capable, this can be narrowed later without
+ * changing call sites (an async fn can always wrap a sync value).
+ *
+ * `payload` is intentionally `unknown` at the store layer — the store's job
+ * is durable persistence + dedup, not payload semantics. The effectively-once
+ * logic (`outbox.ts` / `inbox.ts`) is equally payload-agnostic; only the
+ * eventual wiring slice (notify_peer / `/notify`) will narrow `payload` to a
+ * concrete `NotifyPayload`-shaped type.
+ */
+import { z } from 'zod';
+// ---------------------------------------------------------------------------
+// Outbox entry — the sender-side persisted record (DR-038 Decisions 1, 2, 4).
+// ---------------------------------------------------------------------------
+export const OutboxEntrySchema = z.object({
+    /**
+     * UUIDv4 message-id, minted ONCE at enqueue (DR-038 Decision 2) via
+     * `mintMessageId()` (`message-id.ts`). Persisted verbatim; NEVER
+     * regenerated on retry — that stability is the whole receiver-side dedup
+     * key (Decision 1).
+     */
+    id: z.string().min(1),
+    /**
+     * Driver-agnostic routing target identifier (e.g. an agent/routing-label,
+     * or a target URL — whatever the caller's `send` seam expects as its
+     * first argument). Opaque to the store.
+     */
+    target: z.string().min(1),
+    /** Opaque message payload. JSON-serializable is assumed but not enforced here. */
+    payload: z.unknown(),
+    /** Epoch-ms at first enqueue. Used for wall-clock TTL expiry (Decision 4). */
+    enqueuedAt: z.number(),
+    /** Epoch-ms of the next scheduled attempt (immediate on first enqueue). */
+    nextAttemptAt: z.number(),
+    /** Count of send attempts made so far (0 before the first attempt). */
+    attemptCount: z.number().int().nonnegative(),
+});
+// ---------------------------------------------------------------------------
+// Inbox entry — the receiver-side persisted record (DR-038 Decisions 1, 3).
+// ---------------------------------------------------------------------------
+export const InboxEntrySchema = z.object({
+    /** The sender's message-id — the dedup key (DR-038 Decisions 1, 2). */
+    id: z.string().min(1),
+    /** Opaque message payload, as durably received. */
+    payload: z.unknown(),
+    /** Epoch-ms at receipt (persist time, i.e. before ACK — Decision 3). */
+    receivedAt: z.number(),
+    /** Has the drain processed this entry yet? (Decision 5). */
+    processed: z.boolean(),
+});
+//# sourceMappingURL=store.js.map

package/dist/delivery/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","sourceRoot":"","sources":["../../src/delivery/store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,8EAA8E;AAC9E,8EAA8E;AAC9E,8EAA8E;AAE9E,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC;;;;;OAKG;IACH,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACrB;;;;OAIG;IACH,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACzB,kFAAkF;IAClF,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE;IACpB,8EAA8E;IAC9E,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,2EAA2E;IAC3E,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;IACzB,uEAAuE;IACvE,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;CAC7C,CAAC,CAAC;AAGH,8EAA8E;AAC9E,4EAA4E;AAC5E,8EAA8E;AAE9E,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,uEAAuE;IACvE,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACrB,mDAAmD;IACnD,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE;IACpB,wEAAwE;IACxE,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,4DAA4D;IAC5D,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE;CACvB,CAAC,CAAC"}

package/dist/discovery.d.ts

@@ -2,8 +2,10 @@
  * The workspace-discovery record + its pure helpers (DR-037 Decision 4).
  *
  * This is the shared substrate the fleet operational-layer subcommands consume:
- * `macf ps` (alive∪dead enumeration), `macf fleet upgrade` (group-by-registry →
- * fleets), and the watchdog (desired-set reconcile) all read the same primitive.
+ * `macf ps` (alive∪dead enumeration), `macf fleet upgrade` (group-by-PROJECT →
+ * fleets — macf#710; a project owns its own CA + registry namespace, so it is
+ * the correct grouping key, NOT the coarser `registry` scope), and the watchdog
+ * (desired-set reconcile) all read the same primitive.
  *
  * The record shape + the RUNTIME-and-CLI-independent helpers live HERE in
  * macf-core (DR-037 OQ2 — pure/portable logic in macf-core); the VM-filesystem
@@ -25,22 +27,31 @@ export declare const WorkspaceRecordSchema: z.ZodObject<{
     agent: z.ZodString;
     workspace: z.ZodString;
     registry: z.ZodString;
+    project: z.ZodString;
     versionPin: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 export type WorkspaceRecord = z.infer<typeof WorkspaceRecordSchema>;
 /**
- * Render a `RegistryConfig` as its stable fleet-grouping identifier (a "fleet"
- * == a registry — DR-037 Decision 1). Pure.
+ * Render a `RegistryConfig` as its stable, human-legible identifier. Pure.
  *
  * - `repo`    → `owner/repo`
  * - `org`     → the org name
- * - `profile` → the profile user name (the substrate case: every `groundnuty`
- *               profile-registry workspace groups into one fleet)
+ * - `profile` → the profile user name (e.g. every `groundnuty` profile-registry
+ *               workspace, REGARDLESS of which project it belongs to, renders
+ *               the same identifier here — it names the shared NETWORK ENDPOINT,
+ *               not a fleet)
  * - `local`   → `local` (DR-024)
  *
+ * NOTE (macf#710): this identifier is NOT the fleet-grouping key — see
+ * `WorkspaceRecord.project` for that. Prior to #710, `fleet upgrade` grouped by
+ * this identifier (DR-037 Decision 1's original framing), which collapsed
+ * distinct projects sharing one profile/org registry scope into a single fleet.
+ * `registryIdentifier` remains useful for display + for resolving a genuinely
+ * registry-scoped target (e.g. `fleet-resume`'s repo-scoped alert-repo lookup).
+ *
  * Org and profile scopes collapse to a bare name; a theoretical `org foo` vs
- * `profile foo` collision is accepted for this grouping heuristic (they are not
- * both used by one host in practice) and keeps the identifier human-legible.
+ * `profile foo` collision is accepted for this heuristic (they are not both
+ * used by one host in practice) and keeps the identifier human-legible.
  */
 export declare function registryIdentifier(config: RegistryConfig): string;
 /**

package/dist/discovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../src/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;iBAuBhC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CAWjE;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,SAAS,MAAM,EAAE,CAM1F;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,eAAe,EAAE,GAClC,SAAS,eAAe,EAAE,CAS5B"}
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../src/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;iBA2ChC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CAWjE;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,SAAS,MAAM,EAAE,CAM1F;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,eAAe,EAAE,GAClC,SAAS,eAAe,EAAE,CAS5B"}

package/dist/discovery.js

@@ -2,8 +2,10 @@
  * The workspace-discovery record + its pure helpers (DR-037 Decision 4).
  *
  * This is the shared substrate the fleet operational-layer subcommands consume:
- * `macf ps` (alive∪dead enumeration), `macf fleet upgrade` (group-by-registry →
- * fleets), and the watchdog (desired-set reconcile) all read the same primitive.
+ * `macf ps` (alive∪dead enumeration), `macf fleet upgrade` (group-by-PROJECT →
+ * fleets — macf#710; a project owns its own CA + registry namespace, so it is
+ * the correct grouping key, NOT the coarser `registry` scope), and the watchdog
+ * (desired-set reconcile) all read the same primitive.
  *
  * The record shape + the RUNTIME-and-CLI-independent helpers live HERE in
  * macf-core (DR-037 OQ2 — pure/portable logic in macf-core); the VM-filesystem
@@ -30,12 +32,32 @@ export const WorkspaceRecordSchema = z.object({
      */
     workspace: z.string(),
     /**
-     * The registry this workspace belongs to, as a stable GROUPING identifier —
-     * `owner/repo` (repo scope), the org / profile-user name (org / profile
-     * scope), or `local` (DR-024 local-registry mode). A "fleet" == a registry,
-     * so `fleet upgrade` groups by this field. Derive via `registryIdentifier`.
+     * The registry this workspace belongs to, as a stable identifier — `owner/repo`
+     * (repo scope), the org / profile-user name (org / profile scope), or `local`
+     * (DR-024 local-registry mode). Derive via `registryIdentifier`.
+     *
+     * NOT the fleet-grouping key (macf#710) — a profile/org registry scope is the
+     * NETWORK ENDPOINT (e.g. the `groundnuty/groundnuty` GitHub repo backing a
+     * profile registry), which multiple DISTINCT projects can share. Each project
+     * has its own registry NAMESPACE (`MACF_AGENT_*` vs `ICSOC_2026_AGENT_*`) and
+     * its own CA (`MACF_CA_CERT` vs `ICSOC_2026_CA_CERT` — see
+     * `createVmDriverFromConfig`'s `${toVariableSegment(config.project)}_CA_CERT`
+     * lookup). Grouping by `registry` collapsed distinct projects sharing one
+     * profile/org scope into a single fleet, so a driver built from one project's
+     * workspace (its CA) was used to probe the other project's agents — wrong CA,
+     * false-negative UNREACHABLE. See `project` below for the correct grouping key.
      */
     registry: z.string(),
+    /**
+     * The project this workspace belongs to (`.macf/macf-agent.json` `project`) —
+     * its own CA + registry namespace + version cadence. THE fleet-grouping key
+     * (macf#710, superseding the pre-#710 `registry`-based grouping): `fleet
+     * upgrade` groups discovered workspaces by this field, so a `groundnuty`
+     * profile-registry host running BOTH `macf` and `icsoc_2026` projects
+     * discovers as TWO fleets, each rolled with a driver bound to that project's
+     * own CA — no cross-project probe mismatch.
+     */
+    project: z.string(),
     /**
      * The workspace's pinned framework version (`.macf/macf-agent.json`
      * `versions.cli`), or `null` when the config carries no pin (legacy / pre-P6).
@@ -45,18 +67,26 @@ export const WorkspaceRecordSchema = z.object({
     versionPin: z.string().nullable(),
 });
 /**
- * Render a `RegistryConfig` as its stable fleet-grouping identifier (a "fleet"
- * == a registry — DR-037 Decision 1). Pure.
+ * Render a `RegistryConfig` as its stable, human-legible identifier. Pure.
  *
  * - `repo`    → `owner/repo`
  * - `org`     → the org name
- * - `profile` → the profile user name (the substrate case: every `groundnuty`
- *               profile-registry workspace groups into one fleet)
+ * - `profile` → the profile user name (e.g. every `groundnuty` profile-registry
+ *               workspace, REGARDLESS of which project it belongs to, renders
+ *               the same identifier here — it names the shared NETWORK ENDPOINT,
+ *               not a fleet)
  * - `local`   → `local` (DR-024)
  *
+ * NOTE (macf#710): this identifier is NOT the fleet-grouping key — see
+ * `WorkspaceRecord.project` for that. Prior to #710, `fleet upgrade` grouped by
+ * this identifier (DR-037 Decision 1's original framing), which collapsed
+ * distinct projects sharing one profile/org registry scope into a single fleet.
+ * `registryIdentifier` remains useful for display + for resolving a genuinely
+ * registry-scoped target (e.g. `fleet-resume`'s repo-scoped alert-repo lookup).
+ *
  * Org and profile scopes collapse to a bare name; a theoretical `org foo` vs
- * `profile foo` collision is accepted for this grouping heuristic (they are not
- * both used by one host in practice) and keeps the identifier human-legible.
+ * `profile foo` collision is accepted for this heuristic (they are not both
+ * used by one host in practice) and keeps the identifier human-legible.
  */
 export function registryIdentifier(config) {
     switch (config.type) {

package/dist/discovery.js.map

@@ -1 +1 @@
-{"version":3,"file":"discovery.js","sourceRoot":"","sources":["../src/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C,8EAA8E;IAC9E,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IACjB;;;;OAIG;IACH,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;IACrB;;;;;OAKG;IACH,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB;;;;;OAKG;IACH,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAClC,CAAC,CAAC;AAIH;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAsB;IACvD,QAAQ,MAAM,CAAC,IAAI,EAAE,CAAC;QACpB,KAAK,MAAM;YACT,OAAO,GAAG,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;QAC1C,KAAK,KAAK;YACR,OAAO,MAAM,CAAC,GAAG,CAAC;QACpB,KAAK,SAAS;YACZ,OAAO,MAAM,CAAC,IAAI,CAAC;QACrB,KAAK,OAAO;YACV,OAAO,OAAO,CAAC;IACnB,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,QAAmC;IACrE,IAAI,CAAC,QAAQ;QAAE,OAAO,EAAE,CAAC;IACzB,OAAO,QAAQ;SACZ,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;SACpB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACjC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAC9B,OAAmC;IAEnC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,GAAG,GAAsB,EAAE,CAAC;IAClC,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACxB,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;YAAE,SAAS;QACpC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QACtB,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACd,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}
+{"version":3,"file":"discovery.js","sourceRoot":"","sources":["../src/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C,8EAA8E;IAC9E,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IACjB;;;;OAIG;IACH,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;IACrB;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB;;;;;;;;OAQG;IACH,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB;;;;;OAKG;IACH,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAClC,CAAC,CAAC;AAIH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAsB;IACvD,QAAQ,MAAM,CAAC,IAAI,EAAE,CAAC;QACpB,KAAK,MAAM;YACT,OAAO,GAAG,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;QAC1C,KAAK,KAAK;YACR,OAAO,MAAM,CAAC,GAAG,CAAC;QACpB,KAAK,SAAS;YACZ,OAAO,MAAM,CAAC,IAAI,CAAC;QACrB,KAAK,OAAO;YACV,OAAO,OAAO,CAAC;IACnB,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,QAAmC;IACrE,IAAI,CAAC,QAAQ;QAAE,OAAO,EAAE,CAAC;IACzB,OAAO,QAAQ;SACZ,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;SACpB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACjC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAC9B,OAAmC;IAEnC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,GAAG,GAAsB,EAAE,CAAC;IAClC,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACxB,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;YAAE,SAAS;QACpC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QACtB,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACd,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/fleet-driver.d.ts

@@ -98,6 +98,78 @@ export interface FleetDriver {
      * DEAD/absent agent is not busy (safe to `launch`).
      */
     readonly isBusy: (agent: string) => Promise<boolean>;
+    /**
+     * The pre-flight config-dirty predicate (macf#722 Fix B) — `true` when the
+     * agent's workspace has UNCOMMITTED changes on the roll's touched-config
+     * surface (the macf#725 UNION: the macf-update overwrite set ∪ the
+     * operator-evolution files — `claude.sh`, `.claude/rules/**`,
+     * `.claude/scripts/**`, `.claude/settings.json`, the managed
+     * `.claude/.macf/env.*` + `host-prelude.sh`, `CLAUDE.md`, `env.local.*` —
+     * see `ROLL_TOUCHED_CONFIG_PATTERNS` in `fleet-upgrade.ts`, narrowed off a
+     * `.claude/**` wildcard by DR-040 Decision 6 / macf#698). VM: `git status`
+     * in the agent's workspace, filtered to that path set. A DEAD/absent agent
+     * reads `false` (nothing to check; reconcile will launch it). Kept as a
+     * boolean convenience alongside `listDirtyConfig` below — `rollFleet`'s
+     * pre-flight gate itself calls `listDirtyConfig` (it needs the file list to
+     * OBJECT with, macf#725), so this predicate form is for OTHER callers that
+     * only need the yes/no answer.
+     */
+    readonly isConfigDirty: (agent: string) => Promise<boolean>;
+    /**
+     * The pre-flight config-dirty gate's LIST form (macf#725 — transactional
+     * object-with-message revision). Same predicate surface as `isConfigDirty`
+     * (`ROLL_TOUCHED_CONFIG_PATTERNS`, tracked-only), but returns the actual
+     * uncommitted paths rather than a boolean. Empty array == clean
+     * (equivalent to `isConfigDirty` reading `false`). VM: `git status
+     * --porcelain` in the agent's workspace, filtered to that path set, one
+     * path per line.
+     *
+     * **Superseded as `rollFleet`'s pre-flight call site by `classifyDirtyConfig`
+     * below (DR-040 Decision 3 / macf#698 R1)** — the roll no longer treats
+     * every dirty file as an OBJECT-worthy delta; it tiers them first. This
+     * verb remains on the interface (still used internally by
+     * `classifyDirtyConfig`'s real implementation, and by other callers that
+     * only need the raw uncommitted-path list without tier classification).
+     */
+    readonly listDirtyConfig: (agent: string) => Promise<readonly string[]>;
+    /**
+     * The pre-flight config-dirty gate's TIERED form (DR-040 Decision 3 /
+     * macf#698 R1 — this is what `rollFleet` actually calls now). Splits
+     * `listDirtyConfig`'s raw uncommitted-path list into two tiers by
+     * comparing each file's CURRENT (dirty) content against what `macf
+     * update` would write for it right now (the canonical-compute primitive,
+     * `packages/macf/src/cli/fleet/canonical-compute.ts`):
+     *
+     * - `alreadyCanonical` — the file's content already IS the canonical
+     *   regen (the common case: a stale-branch workspace whose "dirty" files
+     *   are exactly what a fresh `macf update` would produce — both code-agent
+     *   AND science hit only this tier on the v0.2.48 roll). Safe to commit
+     *   as-is; NEVER a genuine conflict.
+     * - `genuineDelta` — a real local difference from canonical. Still
+     *   requires the OBJECT-and-halt treatment `listDirtyConfig`'s callers
+     *   used to apply to the WHOLE dirty list.
+     *
+     * Both arrays are empty when the agent has no dirty config surface at all
+     * (mirrors `listDirtyConfig`'s empty-array-== -clean contract). VM: reuses
+     * `listDirtyConfig` for the raw list, then classifies each path via
+     * `classifyDirtyFile`.
+     */
+    readonly classifyDirtyConfig: (agent: string) => Promise<{
+        readonly alreadyCanonical: readonly string[];
+        readonly genuineDelta: readonly string[];
+    }>;
+    /**
+     * Commit exactly `files` in the agent's workspace (DR-040 Decision 3 /
+     * macf#698 R1) — the auto-resolve half of the tier-first gate. Called ONLY
+     * with `classifyDirtyConfig`'s `alreadyCanonical` subset: those files are,
+     * by construction, deterministic canonical content (not an arbitrary
+     * commit), so committing them clears the false config-dirty signal
+     * without any agent/operator involvement. A no-op when `files` is empty.
+     * VM: `git add -- <files>` + `git commit` in the agent's workspace (a
+     * no-op commit, i.e. nothing actually staged after `add`, is tolerated —
+     * never throws on "nothing to commit").
+     */
+    readonly autoResolveCanonical: (agent: string, files: readonly string[]) => Promise<void>;
     /**
      * Read the agent's current pane content for stall-signature matching
      * (`macf fleet resume`, DR-037 / macf#686). VM: a single `tmux capture-pane`
@@ -113,8 +185,26 @@ export interface FleetDriver {
     /**
      * Restart the agent. VM: `macf restart-self` when ALIVE (graceful — stash +
      * detached relaunch), or `launch` when DEAD. K8s: cycle the pod.
+     *
+     * `opts.leaveConfigUncommitted` (macf#725 — transactional revision, replaces
+     * the earlier unconditional-`forceStashConfig` shape): set ONLY by `rollFleet`
+     * on the restart that immediately follows an `upgrade` in the SAME roll. The
+     * roll's pre-flight `listDirtyConfig` gate already guaranteed the config
+     * surface was clean BEFORE `upgrade` ran; the ONLY dirt an upgrade can leave
+     * behind is `macf update`'s OWN regeneration of the managed surface — which is
+     * supposed to change and must never be silently stashed away (the relaunched
+     * agent needs to SEE it via `git status`). So this tells `restart-self` to
+     * relaunch WITHOUT stashing AND WITHOUT refusing on its own post-upgrade
+     * config-dirty guard — it maps to `restart-self`'s `--leave-config-uncommitted`
+     * flag / `MACF_RESTART_LEAVE_CONFIG_UNCOMMITTED=1`. Omitted (default false,
+     * i.e. the STANDALONE guard stays fully active) for every OTHER caller (e.g. a
+     * direct operator `macf restart-self` invocation, or `fleet-reconcile`'s
+     * healing ladder), which never bypasses the config-dirty gate because it never
+     * checks it in the first place.
      */
-    readonly restart: (agent: string) => Promise<void>;
+    readonly restart: (agent: string, opts?: {
+        readonly leaveConfigUncommitted?: boolean;
+    }) => Promise<void>;
     /**
      * The tier-1 gated nudge — deliver `text` into the agent's live turn loop.
      * VM: the canonical `tmux-send-to-claude` submit pattern. Runtime-specific.
@@ -122,6 +212,56 @@ export interface FleetDriver {
     readonly inject: (agent: string, text: string) => Promise<void>;
     /** Cold-start a desired-but-down agent. VM: spawn its `./claude.sh`. */
     readonly launch: (agent: string) => Promise<void>;
+    /**
+     * List the agent's currently-modified files (macf#725) — used AFTER a
+     * successful `upgrade` to report what `macf update` regenerated in the
+     * relaunched agent's workspace, so the roll's post-upgrade message can name
+     * them explicitly. VM: `git status --porcelain` (all tracked changes, not
+     * scoped to the config-surface patterns — `macf update` can also touch pins /
+     * other managed files outside that surface). Best-effort: an inspection
+     * failure returns an empty list rather than throwing (never blocks reporting
+     * on a diagnostic-only read).
+     */
+    readonly listModifiedFiles: (agent: string) => Promise<readonly string[]>;
+    /**
+     * SET the maintenance lock for `agent` (DR-040 Decision 4,
+     * macf-devops-toolkit#158/#159 — the canonical "upgrade ≠ outage" contract).
+     * Create/overwrite (atomic write; `started_at`/`heartbeat_at` both = now).
+     * `rollFleet` calls this at the TOP of its per-agent transaction, BEFORE
+     * `upgrade`/`restart` touch the agent's process, so a watchdog sweep racing
+     * the very first SIGTERM already reads "planned maintenance," never
+     * "unplanned outage." VM: a lock FILE under
+     * `$MACF_MAINT_LOCK_DIR/<agent>.lock` (same-directory tempfile + `rename`,
+     * atomic); K8s (future): a pod annotation / ConfigMap patch — same
+     * four-verb contract, different storage (the MAINTENANCE-LOCK.md
+     * decision/driver split).
+     */
+    readonly acquireLock: (agent: string, targetVersion: string) => Promise<void>;
+    /**
+     * RELEASE the maintenance lock for `agent` (idempotent — a no-op if none
+     * exists). `rollFleet` calls this ONLY on a confirmed clean GREEN roll — a
+     * HALTed roll deliberately LEAVES the lock in place (DR-040 Decision 3:
+     * the stale heartbeat is the crash-safety backstop, not an immediate
+     * release — see macf-devops-toolkit#158's "release ONLY on confirmed clean
+     * success"). Releasing on failure would hand a possibly-broken, mid-
+     * transition agent straight back to the watchdog's healing ladder the
+     * instant the roll fails — exactly the uncoordinated intervention the
+     * transactional halt exists to avoid.
+     */
+    readonly releaseLock: (agent: string) => Promise<void>;
+    /**
+     * Start a BACKGROUND heartbeat loop refreshing `agent`'s maintenance lock —
+     * decoupled from `rollFleet`'s foreground awaits, because `upgrade` /
+     * `restart` / `verifyGreen` can each individually take a while and the
+     * heartbeat must not stall behind whichever step is currently running.
+     * Returns a synchronous STOP handle the caller invokes exactly once, on
+     * EITHER terminal branch (green or halt) — never both, and never omitted.
+     * VM: a bounded interval (period well under `MAINT_LOCK_TTL`), itself
+     * dead-man's-switch-bounded by `MAINT_LOCK_HEARTBEAT_MAX_S` so an orphaned
+     * loop (e.g. its parent process killed before the stop handle ever runs)
+     * cannot refresh the lock forever.
+     */
+    readonly startHeartbeat: (agent: string) => () => void;
 }
 /**
  * A fleet-driver operation failed against a resolvable target — most commonly an

package/dist/fleet-driver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fleet-driver.d.ts","sourceRoot":"","sources":["../src/fleet-driver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,gDAAgD;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gCAAgC;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gCAAgC;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oEAAoE;IACpE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,wFAAwF;IACxF,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC;CACxC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;CAC7C;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC;IAE1C;;;;;OAKG;IACH,QAAQ,CAAC,kBAAkB,EAAE,MAAM,SAAS,eAAe,EAAE,CAAC;IAE9D;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAErD;;;;;;;;OAQG;IACH,QAAQ,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAEhE,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnD;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnD;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhE,wEAAwE;IACxE,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnD;AAED;;;;;GAKG;AACH,qBAAa,gBAAiB,SAAQ,SAAS;gBACjC,OAAO,EAAE,MAAM;CAI5B"}
+{"version":3,"file":"fleet-driver.d.ts","sourceRoot":"","sources":["../src/fleet-driver.ts"],"names":[],"mappings":"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"}

package/dist/fleet-driver.js.map

@@ -1 +1 @@
-{"version":3,"file":"fleet-driver.js","sourceRoot":"","sources":["../src/fleet-driver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AA0GxC;;;;;GAKG;AACH,MAAM,OAAO,gBAAiB,SAAQ,SAAS;IAC7C,YAAY,OAAe;QACzB,KAAK,CAAC,oBAAoB,EAAE,OAAO,CAAC,CAAC;QACrC,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IACjC,CAAC;CACF"}
+{"version":3,"file":"fleet-driver.js","sourceRoot":"","sources":["../src/fleet-driver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AA4PxC;;;;;GAKG;AACH,MAAM,OAAO,gBAAiB,SAAQ,SAAS;IAC7C,YAAY,OAAe;QACzB,KAAK,CAAC,oBAAoB,EAAE,OAAO,CAAC,CAAC;QACrC,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IACjC,CAAC;CACF"}