@shanesaravia/hive 0.4.0 → 0.5.0

package/packages/server/dist/plans/plansStore.js

@@ -72,6 +72,33 @@ function normalizeGates(gates) {
         return { ...gate, id, label: gate.label.trim(), required: gate.required !== false, evidence: gate.evidence ?? [], waiver: gate.waiver ? { ...gate.waiver, reason: gate.waiver.reason.trim() } : undefined };
     });
 }
+function gateKey(gate) {
+    return `${gate.type}:${gate.label.trim().toLocaleLowerCase().replace(/\s+/g, " ")}`;
+}
+/**
+ * User-created gates are durable requirements, but the orchestrator is the
+ * actor that supplies evidence and reports when the requirement is satisfied.
+ * Reconcile an equivalent reported gate onto the protected user gate instead
+ * of retaining both IDs. The orchestrator may satisfy or fail the requirement,
+ * but only the user may waive it or weaken its definition.
+ */
+function reconcileUserGates(gates) {
+    const userGates = gates.filter((gate) => gate.source === "user");
+    if (!userGates.length)
+        return gates;
+    const reported = gates.filter((gate) => gate.source !== "user");
+    const matches = (userGate) => reported.filter((gate) => gate.id === userGate.id || gateKey(gate) === gateKey(userGate));
+    const matchedIds = new Set(userGates.flatMap((gate) => matches(gate).map((item) => item.id)));
+    const reconciled = userGates.map((gate) => {
+        const equivalents = matches(gate);
+        const satisfied = equivalents.find((item) => item.status === "satisfied");
+        const failed = equivalents.find((item) => item.status === "failed");
+        const status = gate.status === "satisfied" || gate.status === "waived" ? gate.status : satisfied ? "satisfied" : failed ? "failed" : gate.status;
+        const evidence = [...new Set([...(gate.evidence ?? []), ...equivalents.flatMap((item) => item.evidence ?? [])])];
+        return { ...gate, status, evidence };
+    });
+    return [...reported.filter((gate) => !matchedIds.has(gate.id)), ...reconciled];
+}
 /** Durable current plan plus immutable JSON snapshots for revision history. */
 export class PlansStore {
     db;
@@ -91,7 +118,7 @@ export class PlansStore {
         const incoming = input.gates === undefined ? current?.gates ?? [] : normalizeGates(input.gates);
         const protectedUserGates = preserveUserGates ? (current?.gates ?? []).filter((gate) => gate.source === "user") : [];
         const protectedIds = new Set(protectedUserGates.map((gate) => gate.id));
-        const gates = [...incoming.filter((gate) => !protectedIds.has(gate.id)), ...protectedUserGates];
+        const gates = reconcileUserGates([...incoming.filter((gate) => !protectedIds.has(gate.id)), ...protectedUserGates]);
         const plan = { missionId, revision: (current?.revision ?? 0) + 1, updatedAt: Date.now(), phases, gates, layout: input.tasks ? "flat" : "phased", approvalStatus: input.approvalStatus ?? "proposed", approvalReason: input.approvalReason?.trim() || undefined, progress: calculateProgress(phases) };
         const json = JSON.stringify(plan);
         this.db.transaction(() => {
@@ -209,7 +236,10 @@ export class PlansStore {
         this.db.prepare("INSERT OR REPLACE INTO mission_plan_revisions (mission_id, revision, updated_at, plan_json) VALUES (?, ?, ?, ?)").run(newId, revision.revision, revision.updatedAt, JSON.stringify({ ...revision, missionId: newId })); this.db.prepare("DELETE FROM mission_plans WHERE mission_id = ?").run(oldId); this.db.prepare("DELETE FROM mission_plan_revisions WHERE mission_id = ?").run(oldId); })(); }
     get(missionId) {
         const row = this.db.prepare("SELECT plan_json FROM mission_plans WHERE mission_id = ?").get(missionId);
-        return row ? JSON.parse(row.plan_json) : undefined;
+        if (!row)
+            return undefined;
+        const plan = JSON.parse(row.plan_json);
+        return { ...plan, gates: reconcileUserGates(plan.gates ?? []) };
     }
     revisions(missionId) {
         return this.db.prepare("SELECT plan_json FROM mission_plan_revisions WHERE mission_id = ? ORDER BY revision DESC").all(missionId).map((row) => JSON.parse(row.plan_json));

package/packages/server/dist/roster/workerIdentity.js

@@ -131,13 +131,62 @@ const LAUNCH_NAME_GRACE_MS = 3_000;
  */
 export class WorkerIdentityTable {
     missionId;
+    liveJobIds;
     byCanonical = new Map();
     dirty = false;
-    constructor(missionId, seeded = []) {
+    constructor(missionId, seeded = [], liveJobIds = new Set()) {
         this.missionId = missionId;
+        this.liveJobIds = liveJobIds;
         for (const record of seeded)
             this.byCanonical.set(record.canonicalId, { ...record, nativeIds: [...record.nativeIds], labels: [...record.labels], planTaskIds: [...record.planTaskIds], sessionIds: [...record.sessionIds] });
     }
+    /**
+     * Whether this record belongs to a manager other than the one asking, and
+     * so must not be found by name.
+     *
+     * Only a name can be ambiguous. A provider-native agent id is unique by
+     * construction and means the same worker wherever it turns up. A plan task
+     * id and a delegation label are words an orchestrator chose, and two
+     * managers live on one mission choose the same words for different people:
+     * on mission f7ae71c7 two of them delegated plan task `t12` to a worker they
+     * both called `mr-babysitter`, three minutes apart. Matched across the two,
+     * one manager's report retired the other manager's worker.
+     *
+     * Two conditions keep this from splitting workers that ought to merge. The
+     * other job must still be able to act — a job that is over is not competing
+     * for anything, so a task picked up on a later turn still finds the worker
+     * whose task it is. And the worker must still be running: one that has
+     * finished is nobody's to guard, and adopting its task is exactly the retry
+     * this table exists to recognise.
+     */
+    ownedElsewhere(record, jobId) {
+        if (!jobId || !record.lastJobId || record.lastJobId === jobId)
+            return false;
+        return this.liveJobIds.has(record.lastJobId) && !record.doneAt;
+    }
+    /**
+     * A canonical id no other record has taken.
+     *
+     * A native id is unique already. A label is not, and two live managers can
+     * hand the same one to two different workers — where the table used to merge
+     * them it now keeps them apart, and keying both on the label would silently
+     * drop the first from the floor. The label stays the worker's display name
+     * either way; only the key it is filed under gains the owning job.
+     */
+    freeCanonicalId(label, jobId) {
+        if (!this.byCanonical.has(label))
+            return label;
+        const scoped = `${label}#${(jobId ?? "").slice(0, 8)}`;
+        if (jobId && !this.byCanonical.has(scoped))
+            return scoped;
+        for (let suffix = 2; suffix <= this.byCanonical.size + 2; suffix += 1) {
+            const candidate = `${jobId ? scoped : label}#${suffix}`;
+            if (!this.byCanonical.has(candidate))
+                return candidate;
+        }
+        // Unreachable: more candidates are tried above than there are records.
+        return `${label}#${this.byCanonical.size + 3}`;
+    }
     /** Flags a change made by a later pass, so the record set is persisted. */
     markDirty() { this.dirty = true; }
     /**
@@ -165,15 +214,17 @@ export class WorkerIdentityTable {
             if (match)
                 return match;
         }
+        // Names, unlike native ids, can belong to a live sibling manager.
+        const mine = (record) => !this.ownedElsewhere(record, ref.jobId);
         const task = norm(ref.taskId);
         if (task) {
-            const match = this.records().find((record) => record.planTaskIds.some((id) => id.toLowerCase() === task));
+            const match = this.records().find((record) => mine(record) && record.planTaskIds.some((id) => id.toLowerCase() === task));
             if (match)
                 return match;
         }
         const label = norm(ref.label);
         if (label) {
-            const match = this.records().find((record) => record.labels.some((item) => item.toLowerCase() === label));
+            const match = this.records().find((record) => mine(record) && record.labels.some((item) => item.toLowerCase() === label));
             if (match)
                 return match;
         }
@@ -185,13 +236,16 @@ export class WorkerIdentityTable {
     }
     /** Merge this evidence into an existing person, or create one. */
     bind(ref, into, options = {}) {
-        const existing = into ?? (options.allowLabelMerge === false ? this.find({ nativeId: ref.nativeId, taskId: ref.taskId }) : this.find(ref));
+        const existing = into ?? (options.allowLabelMerge === false ? this.find({ nativeId: ref.nativeId, taskId: ref.taskId, jobId: ref.jobId }) : this.find(ref));
         if (!existing) {
             // A native id is the stable, provider-owned name and is preferred as the
             // canonical id. A label-only worker (Codex, or a delegation whose launch
             // hook never arrived) is keyed by its label, scoped to this mission
-            // rather than to a single parent job so a resumed turn reuses it.
-            const canonicalId = ref.nativeId?.trim() || ref.label?.trim();
+            // rather than to a single parent job so a resumed turn reuses it — and
+            // disambiguated by job only where a live sibling already holds the name.
+            const native = ref.nativeId?.trim();
+            const label = ref.label?.trim();
+            const canonicalId = native || (label ? this.freeCanonicalId(label, ref.jobId) : undefined);
             if (!canonicalId)
                 throw new Error("worker identity requires a native id or a label");
             const record = { canonicalId, missionId: this.missionId, nativeIds: [], labels: [], planTaskIds: [], sessionIds: [], startedAt: ref.at, lastJobId: ref.jobId };
@@ -273,14 +327,26 @@ export class WorkerIdentityTable {
             this.dirty = true;
         return existing;
     }
-    /** Canonical id for any alias, or undefined when nothing has claimed it. */
-    canonicalFor(value) {
+    /**
+     * Canonical id for any alias, or undefined when nothing has claimed it.
+     *
+     * `jobId` is the manager speaking. Where two of them are live and have used
+     * the same word for two different workers, the speaker's own worker is the
+     * one it means — without that, a manager reporting its worker finished
+     * retired whichever record happened to be found first, and the wrong avatar
+     * left the floor.
+     */
+    canonicalFor(value, jobId) {
         if (!value)
             return undefined;
         const wanted = norm(value);
         if (!wanted)
             return undefined;
-        return this.records().find((record) => [record.canonicalId, ...record.nativeIds, ...record.labels, ...record.planTaskIds].some((item) => item.toLowerCase() === wanted))?.canonicalId;
+        const matches = this.records().filter((record) => [record.canonicalId, ...record.nativeIds, ...record.labels, ...record.planTaskIds].some((item) => item.toLowerCase() === wanted));
+        if (!matches.length)
+            return undefined;
+        const own = jobId ? matches.find((record) => record.lastJobId === jobId) : undefined;
+        return (own ?? matches.find((record) => !this.ownedElsewhere(record, jobId)) ?? matches[0]).canonicalId;
     }
 }
 /**
@@ -291,9 +357,10 @@ export class WorkerIdentityTable {
  * label stranded as a third. Version 5 stopped a launch under a still-live
  * sibling job being read as a replacement, which merged the workers of
  * concurrent managers into one person — and clears the records those bindings
- * already wrote.
+ * already wrote. Version 6 stopped a plan task or delegation label finding a
+ * live sibling manager's worker at all.
  */
-export const WORKER_IDENTITY_RESOLVER_VERSION = "5";
+export const WORKER_IDENTITY_RESOLVER_VERSION = "6";
 /** Persists resolved identities so they survive the bounded event ring. */
 export class WorkerIdentityStore {
     db;
@@ -361,12 +428,13 @@ export class WorkerIdentityStore {
             .run(JSON.stringify(record), Date.now(), missionId, canonicalId);
     }
     /** Canonical worker id for any alias, label, or plan task id. */
-    canonicalFor(missionId, value) {
+    canonicalFor(missionId, value, jobId) {
         const wanted = value?.trim().toLowerCase();
         if (!wanted)
             return undefined;
-        return this.list(missionId).find((record) => [record.canonicalId, ...record.nativeIds, ...record.labels, ...record.planTaskIds]
-            .some((item) => item.trim().toLowerCase() === wanted))?.canonicalId;
+        const matches = this.list(missionId).filter((record) => [record.canonicalId, ...record.nativeIds, ...record.labels, ...record.planTaskIds]
+            .some((item) => item.trim().toLowerCase() === wanted));
+        return (jobId ? matches.find((record) => record.lastJobId === jobId) : undefined)?.canonicalId ?? matches[0]?.canonicalId;
     }
     removeMission(missionId) {
         this.db.prepare("DELETE FROM mission_workers WHERE mission_id = ?").run(missionId);
@@ -405,7 +473,7 @@ export function resolveMissionWorkers(input) {
     const pairWindowMs = input.pairWindowMs ?? 30_000;
     const liveJobIds = new Set(input.liveJobIds ?? []);
     const planTasksInput = input.planTasks ?? [];
-    const table = new WorkerIdentityTable(missionId, input.seeded);
+    const table = new WorkerIdentityTable(missionId, input.seeded, liveJobIds);
     // 1. Hook lifecycle evidence, keyed by the provider's own agent id.
     const nativeEvidence = new Map();
     // An agent launched by a worker is that worker's activity, not a new person
@@ -545,7 +613,7 @@ export function resolveMissionWorkers(input) {
     // worker there is nothing a name could change, so it binds immediately as it
     // always has; it is two delegations reaching for the same anonymous launch
     // that need the description to arrive first.
-    const contenders = delegations.filter((event) => !table.find({ label: event.targetWorker?.trim() || undefined, taskId: identityTask(event) })?.nativeIds.length).length;
+    const contenders = delegations.filter((event) => !table.find({ label: event.targetWorker?.trim() || undefined, taskId: identityTask(event), jobId: eventJobId(event) })?.nativeIds.length).length;
     // Decide nothing while a name may still be arriving. Deferring the whole
     // pass rather than the individual launch matters: pairing sees every launch
     // at once either way, so waiting cannot change which delegation wins a
@@ -553,7 +621,7 @@ export function resolveMissionWorkers(input) {
     const waitingForNames = contenders > 1
         && launchOrder.some((launch) => !launchIsNamed(launch.nativeId) && now - launch.startedAt < LAUNCH_NAME_GRACE_MS);
     const namedLaunches = waitingForNames ? [] : launchOrder;
-    const needsLaunch = (event) => !table.find({ label: event.targetWorker?.trim() || undefined, taskId: identityTask(event) })?.nativeIds.length;
+    const needsLaunch = (event) => !table.find({ label: event.targetWorker?.trim() || undefined, taskId: identityTask(event), jobId: eventJobId(event) })?.nativeIds.length;
     const pairing = pairDelegationsByName({
         delegations: delegations.filter(needsLaunch),
         launches: namedLaunches.filter((launch) => !claimed.has(launch.nativeId)),
@@ -583,7 +651,7 @@ export function resolveMissionWorkers(input) {
                 return false;
             if (pairing.has(other))
                 return false;
-            const otherNamed = table.find({ label: other.targetWorker?.trim() || undefined, taskId: identityTask(other) });
+            const otherNamed = table.find({ label: other.targetWorker?.trim() || undefined, taskId: identityTask(other), jobId });
             if (otherNamed?.nativeIds.length)
                 return false;
             return Math.abs(startedAt - other.ts) < Math.abs(startedAt - event.ts);
@@ -601,7 +669,7 @@ export function resolveMissionWorkers(input) {
         // An already-known label or plan task wins over the launch: a retried or
         // replaced task keeps its person, and the fresh provider id joins it as
         // another alias instead of taking a second desk.
-        const named = table.find({ label, taskId: identityTask(event) });
+        const named = table.find({ label, taskId: identityTask(event), jobId });
         const known = named ?? (pairable ? table.find({ nativeId: pairable.nativeId }) : undefined);
         // A delegation that already has its worker must not swallow a later,
         // unrelated launch just because it is still inside the pairing window —
@@ -667,7 +735,7 @@ export function resolveMissionWorkers(input) {
         // still running. Merging by description exists for a retry — a fresh id for
         // work whose previous attempt has stopped or been reported — and
         // orchestrators reuse descriptions for parallel workers.
-        const sameName = label ? table.find({ label }) : undefined;
+        const sameName = label ? table.find({ label, jobId: native.jobId }) : undefined;
         const sameNameLive = Boolean(sameName?.nativeIds.length) && sameName.nativeIds.some((id) => { const evidence = nativeEvidence.get(id); return evidence ? !evidence.doneAt : false; })
             && ![sameName.canonicalId, ...sameName.nativeIds, ...sameName.labels, ...sameName.planTaskIds].some((value) => reportedRefs.has(norm(value) ?? ""));
         const ref = { nativeId: native.nativeId, label, jobId: native.jobId, sessionId: native.sessionId, at: native.startedAt };
@@ -691,7 +759,7 @@ export function resolveMissionWorkers(input) {
         // it, and nobody when the manager did.
         const canonical = event.toolName === "Agent"
             ? (event.workerRef?.parentAgentId ? table.canonicalFor(event.workerRef.parentAgentId) : undefined)
-            : table.canonicalFor(event.workerRef?.agentId) ?? table.canonicalFor(event.targetWorker);
+            : table.canonicalFor(event.workerRef?.agentId) ?? table.canonicalFor(event.targetWorker, eventJobId(event));
         if (canonical)
             backgroundedAt.set(canonical, Math.max(backgroundedAt.get(canonical) ?? 0, event.ts));
     }
@@ -703,7 +771,7 @@ export function resolveMissionWorkers(input) {
     for (const event of events) {
         if (event.source !== "custom")
             continue;
-        let canonical = table.canonicalFor(event.targetWorker) ?? table.canonicalFor(event.targetTask);
+        let canonical = table.canonicalFor(event.targetWorker, eventJobId(event)) ?? table.canonicalFor(event.targetTask, eventJobId(event));
         if (!canonical)
             continue;
         // A delegation whose launch was never paired sits as an unpublished label
@@ -861,7 +929,7 @@ export function resolveMissionWorkers(input) {
         // native id is the one that survives.
         const delegationWaiting = !record.published && !record.delegated && record.nativeIds.length > 0
             && delegations.some((other) => eventJobId(other) === jobId && needsLaunch(other)
-                && table.find({ label: other.targetWorker?.trim() || undefined, taskId: identityTask(other) })?.published)
+                && table.find({ label: other.targetWorker?.trim() || undefined, taskId: identityTask(other), jobId: eventJobId(other) })?.published)
             && now - startedAt < correlationGraceMs;
         if (mayYetPair || delegationWaiting || (!corroborated && now - startedAt < correlationGraceMs))
             continue;