@agent-relay/factory 0.1.32 → 0.1.33

package/dist/orchestrator/factory.js

@@ -20,6 +20,7 @@ import { asRecord, parseJsonContent, stableHash, wrappedPayload } from '../write
 import { issueKey } from './batch-tracker.js';
 import { findAgentProcessByName, readProcessIdentity } from './process-identity.js';
 import { readFactoryInFlightRegistry, terminatePids } from './reaper.js';
+import { createFactoryCloudEventV1, factoryCloudReleaseReasonV1, } from '../observability/events.js';
 class ClarificationWakeLeaseLostError extends Error {
 }
 class ClarificationQuestionDeliveryLeaseLostError extends Error {
@@ -119,6 +120,7 @@ export class FactoryLoop {
     #workspaceId;
     #relayflows;
     #worktrees;
+    #reporter;
     #batchView;
     #batchReady;
     #listeners = new Map();
@@ -263,6 +265,7 @@ export class FactoryLoop {
         this.#workspaceId = config.workspaceId ?? 'default';
         this.#relayflows = ports.relayflows;
         this.#worktrees = ports.worktrees;
+        this.#reporter = ports.reporter;
         this.#state = ports.stateStore ?? new InMemoryStateStore({
             batchSize: config.batchSize,
             agentQuestionDedupeLimit: AGENT_QUESTION_DEDUPE_LIMIT,
@@ -1362,6 +1365,7 @@ export class FactoryLoop {
             ]);
             const onlineAgents = new Set(roster.agents.map((agent) => agent.name));
             const activeIssueIdentities = new Set();
+            const legacyUnownedAgentsByIssue = new Map();
             for (const [, lifecycle] of lifecycles) {
                 if (isTerminalDispatchLifecycle(lifecycle))
                     continue;
@@ -1378,12 +1382,26 @@ export class FactoryLoop {
                 if (!onlineAgents.has(agent.name) || !agent.issue)
                     continue;
                 const identity = githubIssueRefIdentity(agent.issue);
-                if (identity)
+                if (!identity)
+                    continue;
+                const isLegacyLocalWorker = this.#usesDurableDispatchLifecycle() &&
+                    this.#fleet.placementLocality === 'local' &&
+                    !agent.node &&
+                    !agent.invocationId &&
+                    !activeIssueIdentities.has(identity);
+                if (isLegacyLocalWorker) {
+                    const agents = legacyUnownedAgentsByIssue.get(identity) ?? [];
+                    agents.push(agent);
+                    legacyUnownedAgentsByIssue.set(identity, agents);
+                }
+                else {
                     activeIssueIdentities.add(identity);
+                }
             }
             return {
                 activeIssueIdentities,
                 onlineAgentNames: onlineAgents,
+                legacyUnownedAgentsByIssue,
             };
         }
         catch (error) {
@@ -1405,9 +1423,14 @@ export class FactoryLoop {
             labels.has('factory:human-review'))
             return false;
         const identity = githubIssueRefIdentity(issueRef(issue));
+        const legacyUnownedAgents = identity
+            ? (context.legacyUnownedAgentsByIssue.get(identity) ?? [])
+                .filter((agent) => githubAgentNameMatchesIssue(agent.name, issue))
+            : [];
+        const legacyUnownedAgentNames = new Set(legacyUnownedAgents.map((agent) => agent.name));
         if (!identity ||
             context.activeIssueIdentities.has(identity) ||
-            [...context.onlineAgentNames].some((name) => githubAgentNameMatchesIssue(name, issue))) {
+            [...context.onlineAgentNames].some((name) => githubAgentNameMatchesIssue(name, issue) && !legacyUnownedAgentNames.has(name))) {
             this.#increment('githubOrphanRecoveriesBlockedActive');
             return false;
         }
@@ -1447,7 +1470,7 @@ export class FactoryLoop {
         if (openPr) {
             let adopted = false;
             try {
-                adopted = await this.#adoptOrphanedGithubPullRequest(issue, openPr);
+                adopted = await this.#adoptOrphanedGithubPullRequest(issue, openPr, legacyUnownedAgents);
             }
             catch (error) {
                 this.#increment('githubOrphanedPullRequestAdoptionFailures');
@@ -1468,6 +1491,14 @@ export class FactoryLoop {
             });
             return false;
         }
+        // A pre-durable local Factory may have left live, registry-proven workers
+        // without a lifecycle record. They are safe to adopt only once their open
+        // PR proves which dispatch they own. Without that proof, preserve the issue
+        // and workers instead of redispatching duplicate agents.
+        if (legacyUnownedAgents.length > 0) {
+            this.#increment('githubOrphanRecoveriesBlockedActive');
+            return false;
+        }
         try {
             if (providerStatus === 'in-progress') {
                 await this.#githubWriteback.setStatus(issue, 'ready');
@@ -1504,7 +1535,7 @@ export class FactoryLoop {
             allowLegacyGithubBranch: true,
         });
     }
-    async #adoptOrphanedGithubPullRequest(issue, pr) {
+    async #adoptOrphanedGithubPullRequest(issue, pr, legacyUnownedAgents = []) {
         const headRef = pr.headRef;
         if (!headRef)
             return false;
@@ -1543,14 +1574,14 @@ export class FactoryLoop {
                     : spec),
             };
         }
-        const durableRemoteAdoption = this.#fleet.placementLocality === 'remote';
+        const durableAdoption = this.#usesDurableDispatchLifecycle();
         const publishedPr = {
             repo: pr.repo,
             number: pr.prNumber,
             url: pr.url ?? `https://github.com/${pr.repo}/pull/${pr.prNumber}`,
             headRef,
         };
-        if (durableRemoteAdoption) {
+        if (durableAdoption) {
             const claim = await this.#claimDispatchLifecycle(decision, false, randomUUID(), {
                 phase: 'published',
                 pullRequest: publishedPr,
@@ -1566,7 +1597,7 @@ export class FactoryLoop {
         const batch = await this.#batch();
         const record = batch.start(decision, false);
         if (!record) {
-            if (durableRemoteAdoption) {
+            if (durableAdoption) {
                 const durable = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(decision.issue));
                 if (durable) {
                     this.#scheduleDispatchLifecycleRetry(inFlightRecordFromLifecycle(durable));
@@ -1576,6 +1607,48 @@ export class FactoryLoop {
             }
             return false;
         }
+        if (durableAdoption && legacyUnownedAgents.length > 0) {
+            const specsByName = new Map(dispatchSpecs(record.decision).map((spec) => [spec.name, spec]));
+            const initialBabysitter = babysitterSpec(issue, this.#config, route);
+            const sharedCheckout = record.decision.implementers.find((candidate) => candidate.repo === initialBabysitter.repo && candidate.baseClonePath && candidate.clonePath);
+            const legacyBabysitter = {
+                ...initialBabysitter,
+                ...(sharedCheckout
+                    ? {
+                        baseClonePath: sharedCheckout.baseClonePath,
+                        clonePath: sharedCheckout.clonePath,
+                        ...(headRef ? { branch: headRef } : {}),
+                        ...(sharedCheckout.existingPullRequestBranch ? { existingPullRequestBranch: true } : {}),
+                    }
+                    : {}),
+                ownedPullRequest: { repo: pr.repo, number: pr.prNumber, path: pr.path },
+            };
+            specsByName.set(legacyBabysitter.name, legacyBabysitter);
+            const adopted = [];
+            for (const agent of legacyUnownedAgents) {
+                const spec = specsByName.get(agent.name);
+                if (!spec)
+                    continue;
+                const invocationId = batch.invocationIdFor(record.issue, spec);
+                batch.recordSpawn(record, spec, invocationId, {
+                    name: agent.name,
+                    sessionRef: agent.sessionRef,
+                    pids: agent.pids,
+                    locality: 'local',
+                });
+                adopted.push({ name: agent.name, invocationId });
+            }
+            if (adopted.length > 0) {
+                this.#fleet.hydrateTracked?.(adopted);
+                await this.#saveDispatchLifecycle(record, 'published', publishedPr);
+                for (const agent of adopted) {
+                    this.#increment('legacyLocalWorkersAdopted');
+                    const tracked = record.agents.get(agent.name);
+                    if (tracked)
+                        await this.#reportAgent(record, tracked, 'agent.adopted');
+                }
+            }
+        }
         await this.#ensureBabysitter(record, {
             repo: pr.repo,
             prNumber: pr.prNumber,
@@ -1585,7 +1658,7 @@ export class FactoryLoop {
         });
         const babysitter = [...record.agents.values()].find((tracked) => tracked.spec.role === 'babysitter');
         if (!babysitter) {
-            if (durableRemoteAdoption)
+            if (durableAdoption)
                 this.#scheduleDispatchLifecycleRetry(record);
             else
                 batch.abandon(record.issue);
@@ -1593,10 +1666,15 @@ export class FactoryLoop {
         }
         record.result = {
             issue: record.issue,
-            agents: [{ name: babysitter.result?.name ?? babysitter.spec.name, role: 'babysitter' }],
+            agents: [...record.agents.values()].map((tracked) => ({
+                name: tracked.result?.name ?? tracked.spec.name,
+                role: tracked.spec.role,
+            })),
             dryRun: false,
         };
         await this.#writeInFlightRegistry();
+        if (durableAdoption)
+            await this.#saveDispatchLifecycle(record, 'running', publishedPr);
         this.#increment('githubOrphanedPullRequestsAdopted');
         return true;
     }
@@ -1778,7 +1856,7 @@ export class FactoryLoop {
         if (existingRecord?.result) {
             return existingRecord.result;
         }
-        if (!dryRun && this.#fleet.placementLocality === 'remote') {
+        if (!dryRun && this.#usesDurableDispatchLifecycle()) {
             const durable = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(decision.issue));
             if (durable && !isTerminalDispatchLifecycle(durable)) {
                 if (durable.result && this.#dispatchLifecycleEpochs.has(issueKey(decision.issue))) {
@@ -1849,19 +1927,19 @@ export class FactoryLoop {
         // Full task rendering is part of the durable spawn specification. It must
         // happen before a remote lifecycle is first claimed so takeover cannot
         // recover a persisted minimal triage task after a crash in this gap.
-        const durableRemoteDispatch = !dryRun && this.#fleet.placementLocality === 'remote';
+        const durableDispatch = !dryRun && this.#usesDurableDispatchLifecycle();
         // Local dispatches need the same deterministic branch identity as remote
         // ones. Without it, every worker starts in the configured shared checkout
         // and concurrent issues can switch each other back to the base branch.
         const isolateLocalWorktree = this.#fleet.placementLocality === 'local' && Boolean(this.#worktrees);
-        const lifecycleRunId = !dryRun && (durableRemoteDispatch || isolateLocalWorktree) ? randomUUID() : undefined;
+        const lifecycleRunId = !dryRun && (durableDispatch || isolateLocalWorktree) ? randomUUID() : undefined;
         if (lifecycleRunId) {
             dispatchDecision = decisionWithLifecycleBranches(dispatchDecision, lifecycleRunId, {
                 isolateLocalWorktree,
             });
         }
         dispatchDecision = await this.#withRenderedDispatchTasks(dispatchDecision, liveIssue);
-        if (durableRemoteDispatch) {
+        if (durableDispatch) {
             const lifecycleClaim = await this.#claimDispatchLifecycle(dispatchDecision, dryRun, lifecycleRunId);
             this.#consumePendingDispatchClarifications(dispatchDecision.issue);
             dispatchDecision = structuredClone(lifecycleClaim.lifecycle.decision);
@@ -1881,7 +1959,7 @@ export class FactoryLoop {
                     return restored.result;
             }
         }
-        if (!durableRemoteDispatch)
+        if (!durableDispatch)
             this.#consumePendingDispatchClarifications(dispatchDecision.issue);
         await this.#recordDispatchAttempt(dispatchDecision.issue);
         const record = batch.start(dispatchDecision, dryRun);
@@ -2057,7 +2135,7 @@ export class FactoryLoop {
             });
         }
     }
-    // Remote backends survive orchestrator restarts: re-adopt the agents recorded
+    // Durable backends survive orchestrator restarts: re-adopt the agents recorded
     // in the durable lifecycle store, restore their full batch/spec association,
     // then reconcile once so exits that happened while this process was down are
     // handled instead of being dropped as unknown agents.
@@ -2097,8 +2175,9 @@ export class FactoryLoop {
                 for (const agent of claim.lifecycle.agents) {
                     const invocationId = agent.tracked.spec.invocationId;
                     const node = agent.tracked.result?.node;
-                    if (invocationId || node)
+                    if (invocationId || node || agent.tracked.result) {
                         agents.push({ name: agent.name, invocationId, node });
+                    }
                 }
             }
             // Migration fallback for registries written before durable lifecycle
@@ -2136,6 +2215,12 @@ export class FactoryLoop {
                 this.#dispatchLifecycleEpochs.delete(key);
                 this.#increment('dispatchLifecycleLeasesLost');
                 const lifecycle = await this.#state.getDispatchLifecycle(this.#workspaceId, key);
+                if (lifecycle) {
+                    await this.#reportLifecycle(lifecycle, 'factory.anomaly', {
+                        level: 'error',
+                        errorCode: 'lease_lost',
+                    });
+                }
                 if (lifecycle && !isTerminalDispatchLifecycle(lifecycle) && lifecycle.phase !== 'waiting-for-human') {
                     this.#scheduleDispatchLifecycleRetry(inFlightRecordFromLifecycle(lifecycle));
                 }
@@ -2171,10 +2256,86 @@ export class FactoryLoop {
         }
         this.#dispatchLifecycleEpochs.set(key, claim.lease.epoch);
         this.#scheduleDispatchLifecycleRenewal();
+        if (claim.created) {
+            await this.#reportLifecycle(claim.lifecycle, 'run.started');
+        }
         return { created: claim.created, lifecycle: claim.lifecycle };
     }
+    #usesDurableDispatchLifecycle() {
+        return this.#fleet.durableOwnership ?? this.#fleet.placementLocality === 'remote';
+    }
+    async #report(input) {
+        if (!this.#reporter)
+            return;
+        try {
+            await this.#reporter.report(createFactoryCloudEventV1(input, {
+                now: () => new Date(this.#clock.now()),
+            }));
+        }
+        catch (error) {
+            // A custom reporter is allowed through the public port, so defend the
+            // orchestration path even if it violates the port's no-reject contract.
+            this.#increment('factoryEventReportingFailures');
+            this.#logger.warn?.('[factory] progress reporter rejected an event', {
+                eventType: input.type,
+                errorClass: telemetryErrorClass(error),
+            });
+        }
+    }
+    async #reportLifecycle(lifecycle, type, options = {}) {
+        await this.#report({
+            type,
+            level: options.level ?? (type === 'run.failed' || type === 'factory.anomaly' ? 'error' : 'info'),
+            runId: lifecycle.runId,
+            phase: lifecycle.phase,
+            status: telemetryRunStatus(lifecycle.phase),
+            run: {
+                source: githubIssuePathParts(lifecycle.issue.path) ? 'github' : 'linear',
+                repository: lifecycle.decision.routes[0]?.repo,
+                issueKey: lifecycle.issue.key,
+                recipe: lifecycle.decision.scope,
+            },
+            attributes: {
+                backend: this.#fleet.placementLocality === 'remote' ? 'relay' : 'internal',
+                component: 'orchestrator',
+                operation: 'save_lifecycle',
+                previousPhase: options.previousPhase,
+                errorCode: options.errorCode,
+                dryRun: lifecycle.dryRun,
+                trackedAgents: lifecycle.agents.length,
+            },
+        });
+    }
+    async #reportAgent(record, tracked, type, options = {}) {
+        const lifecycle = await this.#state
+            .getDispatchLifecycle(this.#workspaceId, issueKey(record.issue))
+            .catch(() => undefined);
+        if (!lifecycle)
+            return;
+        await this.#report({
+            type,
+            runId: lifecycle.runId,
+            phase: lifecycle.phase,
+            status: telemetryRunStatus(lifecycle.phase),
+            run: {
+                source: githubIssuePathParts(record.issue.path) ? 'github' : 'linear',
+                repository: tracked.spec.repo,
+                issueKey: record.issue.key,
+                recipe: record.decision.scope,
+            },
+            attributes: {
+                backend: this.#fleet.placementLocality === 'remote' ? 'relay' : 'internal',
+                component: 'fleet',
+                operation: type.slice('agent.'.length),
+                agentRole: tracked.spec.role,
+                invocationId: tracked.spec.invocationId,
+                locality: tracked.result?.locality ?? this.#fleet.placementLocality,
+                releaseReason: factoryCloudReleaseReasonV1(options.releaseReason),
+            },
+        });
+    }
     async #saveDispatchLifecycle(record, phase, pullRequest, releaseReason, releasedAgentNames = new Set()) {
-        if (record.dryRun || this.#fleet.placementLocality !== 'remote')
+        if (record.dryRun || !this.#usesDurableDispatchLifecycle())
             return true;
         const key = issueKey(record.issue);
         const epoch = this.#dispatchLifecycleEpochs.get(key);
@@ -2195,9 +2356,20 @@ export class FactoryLoop {
         if (!saved) {
             this.#dispatchLifecycleEpochs.delete(key);
             this.#increment('dispatchLifecycleFencesRejected');
+            await this.#reportLifecycle(lifecycle, 'factory.anomaly', {
+                level: 'error',
+                errorCode: 'fence_rejected',
+            });
             this.#scheduleDispatchLifecycleRetry(record);
             return false;
         }
+        if (previous?.phase !== lifecycle.phase) {
+            await this.#reportLifecycle(lifecycle, lifecycle.phase === 'complete'
+                ? 'run.succeeded'
+                : lifecycle.phase === 'abandoned'
+                    ? 'run.cancelled'
+                    : 'run.phase_changed', { previousPhase: previous?.phase });
+        }
         if (isTerminalDispatchLifecycle(lifecycle)) {
             this.#dispatchLifecycleEpochs.delete(key);
         }
@@ -2229,7 +2401,7 @@ export class FactoryLoop {
         this.#dispatchLifecycleRetryTimers.set(key, timer);
     }
     #scheduleReleaseRetry(record, reason) {
-        if (this.#fleet.placementLocality === 'remote') {
+        if (this.#usesDurableDispatchLifecycle()) {
             this.#scheduleDispatchLifecycleRetry(record);
             return;
         }
@@ -2458,14 +2630,14 @@ export class FactoryLoop {
             this.#scheduleReleaseRetry(record, reason);
             return false;
         }
-        const next = this.#fleet.placementLocality === 'remote' ? undefined : batch.complete(record.issue);
+        const next = this.#usesDurableDispatchLifecycle() ? undefined : batch.complete(record.issue);
         this.#localReleaseCheckpoints.delete(releaseKey);
         if (next)
             await this.dispatch(next.decision, { dryRun: next.dryRun });
         // Terminal lifecycle saves intentionally relinquish the owner epoch. Clear
         // the babysitter's durable ownership/wake/critical state while that epoch
         // is still valid so a later reopened issue cannot inherit a stale PR owner.
-        if (this.#fleet.placementLocality === 'remote' && this.#config.babysitter.enabled) {
+        if (this.#usesDurableDispatchLifecycle() && this.#config.babysitter.enabled) {
             await this.#cancelBabysitterWake(issueKey(record.issue));
         }
         if (!await this.#saveDispatchLifecycle(record, 'complete'))
@@ -2480,7 +2652,7 @@ export class FactoryLoop {
         return await this.#assertIssueDispatchLifecycleOwner(record.issue);
     }
     async #assertIssueDispatchLifecycleOwner(issue) {
-        if (this.#fleet.placementLocality !== 'remote')
+        if (!this.#usesDurableDispatchLifecycle())
             return true;
         const key = issueKey(issue);
         const epoch = this.#dispatchLifecycleEpochs.get(key);
@@ -2947,6 +3119,19 @@ export class FactoryLoop {
         await mkdir(dirname(path), { recursive: true });
         await writeFile(path, `${JSON.stringify(heartbeat, null, 2)}\n`, 'utf8');
         await this.#writeInFlightRegistry(registryPath, path);
+        const batch = this.#batchView;
+        await this.#report({
+            type: 'instance.heartbeat',
+            attributes: {
+                backend: this.#fleet.placementLocality === 'remote' ? 'relay' : 'internal',
+                mode: status,
+                component: 'orchestrator',
+                operation: 'heartbeat',
+                activeRuns: batch?.inFlight.length,
+                queuedRuns: batch?.queued.length,
+                trackedAgents: batch?.inFlight.reduce((count, record) => count + record.agents.size, 0),
+            },
+        });
     }
     async #reapDispatchFailureHandoffsNow(heartbeatPath, registryPath) {
         const handoffs = await this.#state.listFailureHandoffs(this.#workspaceId);
@@ -3150,7 +3335,9 @@ export class FactoryLoop {
     async #releaseAndTerminateAgents(agents, reason, context) {
         const failed = [];
         const protectedPids = await this.#protectedPids();
+        const batch = this.#batchView;
         for (const [agentName, tracked] of agents) {
+            const record = batch?.getIssueByAgent(agentName);
             if (context === 'stop') {
                 await this.#refreshStoppingHeartbeat();
             }
@@ -3182,10 +3369,23 @@ export class FactoryLoop {
             }
             try {
                 await this.#fleet.release(agentName, reason);
+                if (record)
+                    await this.#reportAgent(record, tracked, 'agent.released', { releaseReason: reason });
             }
             catch (error) {
                 failed.push(agentName);
                 this.#logger.warn?.(`[factory] failed to release ${agentName} during ${context}`, error);
+                if (record) {
+                    const lifecycle = await this.#state
+                        .getDispatchLifecycle(this.#workspaceId, issueKey(record.issue))
+                        .catch(() => undefined);
+                    if (lifecycle) {
+                        await this.#reportLifecycle(lifecycle, 'factory.failure', {
+                            level: 'error',
+                            errorCode: 'release_failed',
+                        });
+                    }
+                }
             }
             if (context === 'stop') {
                 await this.#refreshStoppingHeartbeat();
@@ -3423,6 +3623,9 @@ export class FactoryLoop {
             if (!await this.#saveDispatchLifecycle(record, 'dispatching')) {
                 throw new Error(`Dispatch lifecycle ownership lost after adopting ${spec.name}`);
             }
+            const adopted = record.agents.get(spec.name);
+            if (adopted)
+                await this.#reportAgent(record, adopted, 'agent.adopted');
             return { name: spec.name };
         }
         await this.#prepareAgentWorktree(record, spec);
@@ -3451,6 +3654,9 @@ export class FactoryLoop {
         if (!await this.#saveDispatchLifecycle(record, 'dispatching')) {
             throw new Error(`Dispatch lifecycle ownership lost after spawning ${spec.name}`);
         }
+        const spawned = record.agents.get(result.name);
+        if (spawned)
+            await this.#reportAgent(record, spawned, 'agent.spawned');
         return { name: result.name };
     }
     async #handleAgentExit(name, reason) {
@@ -3469,6 +3675,19 @@ export class FactoryLoop {
         const batch = await this.#batch();
         const record = batch.getIssueByAgent(name);
         if (!record) {
+            if (/^ar-\d+-/u.test(name)) {
+                await this.#report({
+                    type: 'factory.anomaly',
+                    level: 'error',
+                    attributes: {
+                        backend: this.#fleet.placementLocality === 'remote' ? 'relay' : 'internal',
+                        component: 'fleet',
+                        operation: 'agent_exit',
+                        errorCode: 'unowned_agent',
+                        count: 1,
+                    },
+                });
+            }
             return;
         }
         if (!await this.#assertDispatchLifecycleOwner(record)) {
@@ -3487,7 +3706,9 @@ export class FactoryLoop {
             return;
         }
         const exiting = record.agents.get(name);
-        if (this.#fleet.placementLocality === 'remote') {
+        if (exiting)
+            await this.#reportAgent(record, exiting, 'agent.exited', { releaseReason: reason });
+        if (this.#usesDurableDispatchLifecycle()) {
             const lifecycle = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(record.issue));
             if (lifecycle?.phase === 'parking') {
                 this.#increment('clarificationParkingExitsSuppressed');
@@ -4176,6 +4397,7 @@ export class FactoryLoop {
                 await this.#persistBabysitterSession(record.issue, ref, tracked);
             }
         }
+        await this.#reportAgent(record, tracked, 'agent.resumed');
     }
     async #handleDeliveryFailed(info) {
         const critical = await this.#state.consumeCritical(this.#workspaceId, info.msgId ?? '');
@@ -4185,7 +4407,7 @@ export class FactoryLoop {
         }
         const record = (await this.#batch()).getIssueByAgent(info.to);
         const issue = critical.issue ?? record?.issue;
-        const error = new Error(`Critical delivery failed to ${info.to}${info.reason ? `: ${info.reason}` : ''}`);
+        const error = Object.assign(new Error(`Critical delivery failed to ${info.to}${info.reason ? `: ${info.reason}` : ''}`), { code: 'fleet_delivery_failed' });
         this.#error(error, issue);
         if (isTerminalDeliveryFailure(info.reason)) {
             this.#increment('criticalDeliveryTerminalFailures');
@@ -5661,7 +5883,7 @@ export class FactoryLoop {
     }
     async #cancelBabysitterWake(issueIdentity) {
         const issue = this.#babysitterIssueRefs.get(issueIdentity);
-        const mayClearDurable = this.#fleet.placementLocality !== 'remote'
+        const mayClearDurable = !this.#usesDurableDispatchLifecycle()
             || Boolean(issue && await this.#assertIssueDispatchLifecycleOwner(issue));
         for (const [key, state] of this.#babysitterWakeStates) {
             if (issueKey(state.issue) !== issueIdentity)
@@ -5922,19 +6144,7 @@ export class FactoryLoop {
                 },
             };
             let targets;
-            if (this.#fleet.promptDelivery === 'pty') {
-                if (!this.#fleet.sendInput) {
-                    throw new Error('Fleet client advertises PTY prompt delivery without raw input support');
-                }
-                // Internal agents are harness-owned PTYs, not Relaycast identities.
-                // Stage the validated metadata-only wake directly through the broker so
-                // a missing Relaycast registration cannot strand a live babysitter.
-                // The CR remains a separate write: a critical-section begin can arrive
-                // while this write is in flight and must be able to defer submission.
-                await this.#fleet.sendInput(input.to, input.text);
-                targets = [input.to];
-            }
-            else if (!this.#fleet.waitForInjected) {
+            if (!this.#fleet.waitForInjected) {
                 await this.#fleet.sendMessage(input);
                 if (this.#stopping || state.cancelled) {
                     state.deliveringKinds = undefined;
@@ -6403,7 +6613,12 @@ export class FactoryLoop {
                 prNumber: prRef.prNumber,
                 babysitter: spawned.name,
             });
-            if (this.#fleet.waitForInjected) {
+            // Internal PTY spawns receive `task` atomically in spawnPty. Re-sending
+            // the same task through Relaycast before the worker has registered its
+            // messaging identity can fail an otherwise successful spawn and erase
+            // valid babysitter ownership. Remote placement still needs the explicit,
+            // confirmed follow-up injection used by its spawn protocol.
+            if (this.#fleet.waitForInjected && this.#fleet.placementLocality !== 'local') {
                 const input = {
                     to: tracked?.result?.name ?? spawned.name,
                     text: task,
@@ -6637,7 +6852,7 @@ export class FactoryLoop {
             }
             const releaseReason = humanReview ? 'issue-human-review' : 'issue-done';
             releaseReasonForRetry = releaseReason;
-            if (this.#fleet.placementLocality === 'remote') {
+            if (this.#usesDurableDispatchLifecycle()) {
                 // Durable capacity is released as soon as terminal writeback is
                 // acknowledged. Agent cleanup remains fenced/retryable in `releasing`.
                 const batch = await this.#batch();
@@ -6667,7 +6882,7 @@ export class FactoryLoop {
             this.#babysitterPr.delete(completionKey);
             await this.#cancelBabysitterWake(completionKey);
             const durable = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(record.issue)).catch(() => undefined);
-            if (this.#fleet.placementLocality !== 'remote' || (durable && isTerminalDispatchLifecycle(durable))) {
+            if (!this.#usesDurableDispatchLifecycle() || (durable && isTerminalDispatchLifecycle(durable))) {
                 for (const publishedKey of this.#publishedPullRequests.keys()) {
                     if (publishedKey.startsWith(`${completionKey}:`))
                         this.#publishedPullRequests.delete(publishedKey);
@@ -6677,7 +6892,16 @@ export class FactoryLoop {
     }
     #emit(event, payload) {
         for (const listener of this.#listeners.get(event) ?? []) {
-            listener(payload);
+            try {
+                listener(payload);
+            }
+            catch (error) {
+                this.#increment('factoryEventListenerFailures');
+                this.#logger.warn?.('[factory] event listener failed', {
+                    event,
+                    errorClass: error instanceof Error ? error.name : 'Error',
+                });
+            }
         }
     }
     #error(error, issue) {
@@ -6692,6 +6916,48 @@ export class FactoryLoop {
             ...details,
             ...(issue ? { issue: issue.key } : {}),
         });
+        const failureCode = telemetryCategory(error && typeof error === 'object' && 'code' in error && typeof error.code === 'string'
+            ? error.code
+            : 'factory_error');
+        const failureClass = telemetryErrorClass(error);
+        void (async () => {
+            try {
+                const lifecycle = issue
+                    ? await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(issue)).catch(() => undefined)
+                    : undefined;
+                if (lifecycle) {
+                    await this.#reportLifecycle(lifecycle, 'factory.failure', {
+                        level: 'error',
+                        errorCode: failureCode,
+                    });
+                    return;
+                }
+                await this.#report({
+                    type: 'factory.failure',
+                    level: 'error',
+                    attributes: {
+                        backend: this.#fleet.placementLocality === 'remote' ? 'relay' : 'internal',
+                        component: 'orchestrator',
+                        operation: 'error',
+                        errorClass: failureClass,
+                        errorCode: failureCode,
+                    },
+                });
+            }
+            catch (telemetryError) {
+                // This is the terminal guard for the intentionally floating telemetry
+                // task. Never log raw messages or allow a custom logger to turn this
+                // best-effort path into an unhandled rejection.
+                try {
+                    this.#logger.warn?.('[factory] failed to report failure telemetry', {
+                        errorClass: telemetryErrorClass(telemetryError),
+                    });
+                }
+                catch {
+                    // Reporting and logging are both non-critical to orchestration.
+                }
+            }
+        })();
         this.#emit('error', { error, ...details, issue });
     }
     #surfaceEscalationDeliveryFailure(kind, issue, correlationId, reason, cause) {
@@ -7755,7 +8021,7 @@ export class FactoryLoop {
             }
             let lifecycleDecision = waiting.decision;
             let promotedLifecycle;
-            if (!waiting.dryRun && this.#fleet.placementLocality === 'remote') {
+            if (!waiting.dryRun && this.#usesDurableDispatchLifecycle()) {
                 try {
                     const claim = await this.#claimDispatchLifecycle(waiting.decision, false);
                     const lifecycleKey = issueKey(waiting.issue);
@@ -10046,9 +10312,36 @@ const failedIterationReport = (error, dryRun) => {
 };
 const isRegistrationLagInjectionError = (error) => {
     const { errorMessage } = describeError(error);
-    return /recipient unavailable|not registered|unknown recipient|no such (agent|recipient)|timed out waiting for delivery_injected/i
+    return /agent_not_found|recipient unavailable|not registered|unknown recipient|no such (agent|recipient)|timed out waiting for delivery_injected/i
         .test(errorMessage);
 };
+const telemetryRunStatus = (phase) => {
+    switch (phase) {
+        case 'queued':
+            return 'queued';
+        case 'retryable':
+            return 'blocked';
+        case 'parking':
+        case 'waiting-for-human':
+            return 'waiting';
+        case 'complete':
+            return 'succeeded';
+        case 'abandoned':
+            return 'cancelled';
+        default:
+            return 'running';
+    }
+};
+const telemetryCategory = (value) => {
+    if (!value)
+        return undefined;
+    const normalized = value.trim().toLowerCase().replace(/[^a-z0-9._:/-]+/gu, '-');
+    return normalized.slice(0, 120) || undefined;
+};
+const telemetryErrorClass = (error) => {
+    const name = error instanceof Error ? error.name : '';
+    return /^[A-Za-z][A-Za-z0-9]{0,63}(?:Error|Exception)$/u.test(name) ? name : 'Error';
+};
 const isTimeoutError = (error) => error instanceof Error && (error.name === 'TimeoutError' || error.name === 'AbortError');
 const retryOnTimeout = async (fn, opts) => {
     let lastError;