@atolis-hq/wake 0.2.29 → 0.2.31

package/dist/src/adapters/claude/claude-runner.js

@@ -218,6 +218,7 @@ export function createClaudeRunner(options) {
                 args,
                 cwd: input.workspacePath ?? options.cwd,
                 timeoutMs: options.settings.timeoutMs,
+                ...(input.onProcessStart === undefined ? {} : { onProcessStart: input.onProcessStart }),
             });
             const responseTranscriptPath = await writeRunnerTranscript({
                 config: input.config,

package/dist/src/adapters/codex/codex-runner.js

@@ -261,6 +261,7 @@ export function createCodexRunner(options) {
                 }),
                 cwd,
                 timeoutMs: options.settings.timeoutMs,
+                ...(input.onProcessStart === undefined ? {} : { onProcessStart: input.onProcessStart }),
             });
             const responseTranscriptPath = await writeRunnerTranscript({
                 config: input.config,

package/dist/src/adapters/cursor/cursor-runner.js

@@ -212,6 +212,7 @@ export function createCursorRunner(options) {
                 }),
                 cwd,
                 timeoutMs: options.settings.timeoutMs,
+                ...(input.onProcessStart === undefined ? {} : { onProcessStart: input.onProcessStart }),
             });
             const responseTranscriptPath = await writeRunnerTranscript({
                 config: input.config,

package/dist/src/adapters/fake/fake-ticketing-system.js

@@ -125,6 +125,8 @@ export function createFakeTicketingSystem(options) {
                         trigger: 'context-only',
                         payload: {
                             intentEventId: input.event.eventId,
+                            idempotencyKey: input.event.payload.idempotencyKey,
+                            deliveryState: 'CONFIRMED',
                             labels,
                         },
                     }),
@@ -149,6 +151,9 @@ export function createFakeTicketingSystem(options) {
                     trigger: 'context-only',
                     payload: {
                         intentEventId: input.event.eventId,
+                        idempotencyKey: input.event.payload.idempotencyKey,
+                        deliveryState: 'CONFIRMED',
+                        providerId: commentId,
                         kind: input.event.payload.kind,
                         body: input.event.payload.body,
                     },

package/dist/src/adapters/fs/state-store.js

@@ -172,6 +172,13 @@ export function createStateStore({ wakeRoot }) {
             await writeJsonFile(paths.runDateFile(parsed.startedAt.slice(0, 10), parsed.runId), parsed);
             return parsed;
         },
+        async updateRunRecordIf(runId, input) {
+            const current = await this.readRunRecord(runId);
+            if (current === null || !input.expect(current)) {
+                return null;
+            }
+            return this.writeRunRecord(input.update(current));
+        },
         async writeSourceState(record) {
             const parsed = parseSourceStateRecord(record);
             await writeJsonFile(paths.sourceStateFile(parsed.source, parsed.key), parsed);

package/dist/src/adapters/github/github-issues-work-source.js

@@ -18,6 +18,11 @@ const pollOverlapMs = 60 * 60 * 1000;
 // expectedEcho bookkeeping surviving a crash (#145).
 const wakeCommentMarker = '<!-- wake:agent -->';
 const githubSource = 'github';
+export function wakeIdempotencyMarker(idempotencyKey) {
+    return typeof idempotencyKey === 'string'
+        ? `<!-- wake:idempotency ${idempotencyKey} -->`
+        : undefined;
+}
 function normalizeTicketUpsert(input) {
     // Names the resource, never the work item — the resolver stamps the
     // canonical workItemKey after the poll (spec D1).
@@ -210,6 +215,7 @@ export function formatWakeComment(payload, controlPlaneUrl) {
     const tokens = typeof payload.tokens === 'string' ? payload.tokens : undefined;
     const cost = typeof payload.cost === 'string' ? payload.cost : undefined;
     const workspacePath = typeof payload.workspacePath === 'string' ? payload.workspacePath : undefined;
+    const idempotencyMarker = wakeIdempotencyMarker(payload.idempotencyKey);
     const details = [
         action === undefined ? undefined : `stage \`${action}\``,
         runnerName === undefined ? undefined : `runner \`${runnerName}\``,
@@ -225,7 +231,7 @@ export function formatWakeComment(payload, controlPlaneUrl) {
         ? defaultAgentIdentity
         : `[${defaultAgentIdentity}](${controlPlaneUrl})`;
     const header = `**${name}** _(Wake ${wakeVersion}${details.length > 0 ? ` · ${details.join(' · ')}` : ''})_`;
-    const sections = [wakeCommentMarker, header, body];
+    const sections = [wakeCommentMarker, idempotencyMarker, header, body].filter((section) => section !== undefined);
     if (kind === 'approval-request') {
         sections.push('_To approve this work, reply with `/approved`. To request changes, reply with `/changes` followed by your feedback. To ask a question without requesting changes, reply with `/ask` followed by your question._');
     }
@@ -257,6 +263,33 @@ export function formatWakeComment(payload, controlPlaneUrl) {
     }
     return sections.join('\n\n');
 }
+function createIssueCommentPublishedEvent(input) {
+    return createEventEnvelope({
+        eventId: `${input.event.eventId}-published`,
+        workItemKey: input.event.workItemKey,
+        streamScope: 'work-item',
+        direction: 'outbound',
+        sourceSystem: 'github',
+        sourceEventType: 'ticket.reply.published',
+        sourceRefs: {
+            repo: input.repo,
+            issueNumber: input.issueNumber,
+            ...(input.commentId === undefined ? {} : { commentId: input.commentId }),
+        },
+        occurredAt: input.publishedAt,
+        ingestedAt: input.publishedAt,
+        trigger: 'context-only',
+        payload: {
+            intentEventId: input.event.eventId,
+            idempotencyKey: input.event.payload.idempotencyKey,
+            deliveryState: 'CONFIRMED',
+            kind: input.event.payload.kind,
+            body: input.event.payload.body,
+            providerEventType: 'github.issue.comment.published',
+            ...(input.commentId === undefined ? {} : { providerId: input.commentId }),
+        },
+    });
+}
 export function createGitHubIssuesWorkSource(deps) {
     /** O(1): one shard read, then a direct projection read by work id. */
     async function readProjectionForIssue(repo, issueNumber) {
@@ -398,6 +431,8 @@ export function createGitHubIssuesWorkSource(deps) {
                             trigger: 'context-only',
                             payload: {
                                 intentEventId: input.event.eventId,
+                                idempotencyKey: input.event.payload.idempotencyKey,
+                                deliveryState: 'CONFIRMED',
                                 ...(nextStatusLabel !== undefined ? { statusLabel: nextStatusLabel } : {}),
                                 ...(nextStageLabel !== undefined ? { stageLabel: nextStageLabel } : {}),
                                 ...(nextWorkflowLabel !== undefined ? { workflowLabel: nextWorkflowLabel } : {}),
@@ -412,27 +447,75 @@ export function createGitHubIssuesWorkSource(deps) {
             const response = await deps.client.createComment(owner, repoName, issueNumber, formatWakeComment(input.event.payload, await readControlPlaneUiUrl(deps.config.paths.wakeRoot)));
             const commentId = extractCreatedCommentId(response);
             return [
-                createEventEnvelope({
-                    eventId: `${input.event.eventId}-published`,
-                    workItemKey: input.event.workItemKey,
-                    streamScope: 'work-item',
-                    direction: 'outbound',
-                    sourceSystem: 'github',
-                    sourceEventType: 'ticket.reply.published',
-                    sourceRefs: {
-                        repo,
-                        issueNumber,
-                        ...(commentId === undefined ? {} : { commentId }),
-                    },
-                    occurredAt: publishedAt,
-                    ingestedAt: publishedAt,
-                    trigger: 'context-only',
-                    payload: {
-                        intentEventId: input.event.eventId,
-                        kind: input.event.payload.kind,
-                        body: input.event.payload.body,
-                        providerEventType: 'github.issue.comment.published',
-                    },
+                createIssueCommentPublishedEvent({
+                    event: input.event,
+                    repo,
+                    issueNumber,
+                    publishedAt,
+                    ...(commentId === undefined ? {} : { commentId }),
+                }),
+            ];
+        },
+        async reconcileIntent(input) {
+            const repo = input.event.sourceRefs.repo;
+            const issueNumber = input.event.sourceRefs.issueNumber;
+            if (repo === undefined || issueNumber === undefined) {
+                return [];
+            }
+            const [owner, repoName] = repo.split('/');
+            if (owner === undefined || repoName === undefined) {
+                return [];
+            }
+            const publishedAt = deps.now().toISOString();
+            if (input.event.sourceEventType === 'wake.labels.requested') {
+                const projection = await deps.stateStore.readIssueState(input.event.workItemKey);
+                const currentLabels = projection?.issue.labels ?? [];
+                const expected = [
+                    input.event.payload.statusLabel,
+                    input.event.payload.stageLabel,
+                    input.event.payload.workflowLabel,
+                ].filter((label) => typeof label === 'string');
+                if (expected.every((label) => currentLabels.includes(label))) {
+                    return [
+                        createEventEnvelope({
+                            eventId: `${input.event.eventId}-labels-updated`,
+                            workItemKey: input.event.workItemKey,
+                            streamScope: 'work-item',
+                            direction: 'outbound',
+                            sourceSystem: 'github',
+                            sourceEventType: 'ticket.labels.updated',
+                            sourceRefs: { repo, issueNumber },
+                            occurredAt: publishedAt,
+                            ingestedAt: publishedAt,
+                            trigger: 'context-only',
+                            payload: {
+                                intentEventId: input.event.eventId,
+                                idempotencyKey: input.event.payload.idempotencyKey,
+                                deliveryState: 'CONFIRMED',
+                                labels: currentLabels,
+                                providerEventType: 'github.issue.labels.updated',
+                            },
+                        }),
+                    ];
+                }
+                return [];
+            }
+            const marker = wakeIdempotencyMarker(input.event.payload.idempotencyKey);
+            if (marker === undefined) {
+                return [];
+            }
+            const comments = await deps.client.listComments(owner, repoName, issueNumber, deps.config.sources.github.polling.commentPageSize);
+            const existing = comments.find((comment) => (comment.body ?? '').includes(marker));
+            if (existing === undefined) {
+                return [];
+            }
+            return [
+                createIssueCommentPublishedEvent({
+                    event: input.event,
+                    repo,
+                    issueNumber,
+                    publishedAt,
+                    commentId: String(existing.id),
                 }),
             ];
         },

package/dist/src/adapters/github/github-pull-request-activity-source.js

@@ -1,6 +1,6 @@
 import { buildResourceUri } from '../../domain/resource-uri.js';
 import { createUnkeyedEventEnvelope, createEventEnvelope } from '../../lib/event-log.js';
-import { formatGitHubError, formatWakeComment, readControlPlaneUiUrl, } from './github-issues-work-source.js';
+import { formatGitHubError, formatWakeComment, readControlPlaneUiUrl, wakeIdempotencyMarker, } from './github-issues-work-source.js';
 const githubPrSource = 'github-pr';
 const wakeCommentMarker = '<!-- wake:agent -->';
 function prResourceUri(repo, number) {
@@ -61,6 +61,27 @@ export function createGitHubPullRequestActivitySource(deps) {
         }
         return { owner, repo, repoRef: `${owner}/${repo}`, number: Number(numberStr) };
     }
+    function reviewThreadRefFromUri(resourceUri) {
+        const locator = resourceUri.split(':').slice(2).join(':');
+        const match = /^([^/]+)\/([^#]+)#(\d+)\/rt_(\d+)$/.exec(locator);
+        if (match === null) {
+            return null;
+        }
+        const [, owner, repo, numberStr, rootIdStr] = match;
+        if (owner === undefined ||
+            repo === undefined ||
+            numberStr === undefined ||
+            rootIdStr === undefined) {
+            return null;
+        }
+        return {
+            owner,
+            repo,
+            repoRef: `${owner}/${repo}`,
+            number: Number(numberStr),
+            rootId: Number(rootIdStr),
+        };
+    }
     async function discoverPullRequests(ingestedAt) {
         const seenPrData = new Map();
         const confirmedOpenRepos = new Set();
@@ -404,19 +425,11 @@ export function createGitHubPullRequestActivitySource(deps) {
             }
             const publishedAt = deps.now().toISOString();
             if (resourceUri.startsWith('github:pr-review-thread:')) {
-                const locator = resourceUri.split(':').slice(2).join(':');
-                const match = /^([^/]+)\/([^#]+)#(\d+)\/rt_(\d+)$/.exec(locator);
-                if (match === null) {
-                    throw new Error(`cannot deliver intent ${input.event.eventId}: malformed review-thread uri ${resourceUri}`);
-                }
-                const [, owner, repo, numberStr, rootIdStr] = match;
-                if (owner === undefined ||
-                    repo === undefined ||
-                    numberStr === undefined ||
-                    rootIdStr === undefined) {
+                const ref = reviewThreadRefFromUri(resourceUri);
+                if (ref === null) {
                     throw new Error(`cannot deliver intent ${input.event.eventId}: malformed review-thread uri ${resourceUri}`);
                 }
-                const response = await deps.client.replyToReviewComment(owner, repo, Number(numberStr), Number(rootIdStr), formatWakeComment(input.event.payload, await readControlPlaneUiUrl(deps.config.paths.wakeRoot)));
+                const response = await deps.client.replyToReviewComment(ref.owner, ref.repo, ref.number, ref.rootId, formatWakeComment(input.event.payload, await readControlPlaneUiUrl(deps.config.paths.wakeRoot)));
                 return [
                     createEventEnvelope({
                         eventId: `${input.event.eventId}-published`,
@@ -434,8 +447,11 @@ export function createGitHubPullRequestActivitySource(deps) {
                         trigger: 'context-only',
                         payload: {
                             intentEventId: input.event.eventId,
+                            idempotencyKey: input.event.payload.idempotencyKey,
+                            deliveryState: 'CONFIRMED',
                             kind: input.event.payload.kind,
                             body: input.event.payload.body,
+                            providerId: response?.id,
                         },
                     }),
                 ];
@@ -444,7 +460,79 @@ export function createGitHubPullRequestActivitySource(deps) {
             if (ref === null) {
                 throw new Error(`cannot deliver intent ${input.event.eventId}: malformed pr uri ${resourceUri}`);
             }
-            await deps.client.createComment(ref.owner, ref.repo, ref.number, formatWakeComment(input.event.payload, await readControlPlaneUiUrl(deps.config.paths.wakeRoot)));
+            const response = await deps.client.createComment(ref.owner, ref.repo, ref.number, formatWakeComment(input.event.payload, await readControlPlaneUiUrl(deps.config.paths.wakeRoot)));
+            return [
+                createEventEnvelope({
+                    eventId: `${input.event.eventId}-published`,
+                    workItemKey: input.event.workItemKey,
+                    streamScope: 'work-item',
+                    direction: 'outbound',
+                    sourceSystem: githubPrSource,
+                    sourceEventType: 'pr.comment.reply.published',
+                    sourceRefs: { repo: ref.repoRef, resourceUri },
+                    occurredAt: publishedAt,
+                    ingestedAt: publishedAt,
+                    trigger: 'context-only',
+                    payload: {
+                        intentEventId: input.event.eventId,
+                        idempotencyKey: input.event.payload.idempotencyKey,
+                        deliveryState: 'CONFIRMED',
+                        kind: input.event.payload.kind,
+                        body: input.event.payload.body,
+                        providerId: response?.data?.id,
+                    },
+                }),
+            ];
+        },
+        async reconcileIntent(input) {
+            const resourceUri = input.event.sourceRefs.resourceUri;
+            const marker = wakeIdempotencyMarker(input.event.payload.idempotencyKey);
+            if (resourceUri === undefined || marker === undefined) {
+                return [];
+            }
+            const publishedAt = deps.now().toISOString();
+            if (resourceUri.startsWith('github:pr-review-thread:')) {
+                const ref = reviewThreadRefFromUri(resourceUri);
+                if (ref === null) {
+                    return [];
+                }
+                const comments = await deps.client.listReviewComments(ref.owner, ref.repo, ref.number, deps.config.sources.github.pullRequests.commentPageSize);
+                const existing = comments.find((comment) => (comment.body ?? '').includes(marker));
+                if (existing === undefined) {
+                    return [];
+                }
+                return [
+                    createEventEnvelope({
+                        eventId: `${input.event.eventId}-published`,
+                        workItemKey: input.event.workItemKey,
+                        streamScope: 'work-item',
+                        direction: 'outbound',
+                        sourceSystem: githubPrSource,
+                        sourceEventType: 'pr.review-comment.reply.published',
+                        sourceRefs: { resourceUri, sourceUrl: existing.html_url },
+                        occurredAt: publishedAt,
+                        ingestedAt: publishedAt,
+                        trigger: 'context-only',
+                        payload: {
+                            intentEventId: input.event.eventId,
+                            idempotencyKey: input.event.payload.idempotencyKey,
+                            deliveryState: 'CONFIRMED',
+                            kind: input.event.payload.kind,
+                            body: input.event.payload.body,
+                            providerId: existing.id,
+                        },
+                    }),
+                ];
+            }
+            const ref = repoAndNumberFromPrUri(resourceUri);
+            if (ref === null) {
+                return [];
+            }
+            const comments = await deps.client.listComments(ref.owner, ref.repo, ref.number, deps.config.sources.github.pullRequests.commentPageSize);
+            const existing = comments.find((comment) => (comment.body ?? '').includes(marker));
+            if (existing === undefined) {
+                return [];
+            }
             return [
                 createEventEnvelope({
                     eventId: `${input.event.eventId}-published`,
@@ -459,8 +547,11 @@ export function createGitHubPullRequestActivitySource(deps) {
                     trigger: 'context-only',
                     payload: {
                         intentEventId: input.event.eventId,
+                        idempotencyKey: input.event.payload.idempotencyKey,
+                        deliveryState: 'CONFIRMED',
                         kind: input.event.payload.kind,
                         body: input.event.payload.body,
+                        providerId: existing.id,
                     },
                 }),
             ];

package/dist/src/adapters/runner/cli-command.js

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import { readProcessIdentity } from '../../lib/process-identity.js';
 const TIMEOUT_KILL_GRACE_MS = 5_000;
 export function runAgentCliCommand(input) {
     return new Promise((resolve, reject) => {
@@ -11,6 +12,16 @@ export function runAgentCliCommand(input) {
         let stderr = '';
         let timedOut = false;
         let killTimer;
+        let startNotification = Promise.resolve();
+        let startNotificationError;
+        if (input.onProcessStart !== undefined && child.pid !== undefined) {
+            const identity = readProcessIdentity(child.pid);
+            if (identity !== null) {
+                startNotification = input.onProcessStart(identity).catch((error) => {
+                    startNotificationError = error;
+                });
+            }
+        }
         const timeoutTimer = input.timeoutMs === undefined
             ? undefined
             : setTimeout(() => {
@@ -29,9 +40,14 @@ export function runAgentCliCommand(input) {
             clearTimeout(killTimer);
             reject(error);
         });
-        child.on('close', (exitCode) => {
+        child.on('close', async (exitCode) => {
             clearTimeout(timeoutTimer);
             clearTimeout(killTimer);
+            await startNotification;
+            if (startNotificationError !== undefined) {
+                reject(startNotificationError);
+                return;
+            }
             resolve({
                 stdout,
                 stderr,

package/dist/src/core/active-run-recovery.js

@@ -1,5 +1,6 @@
-import { readFileLockStatus } from '../lib/lock.js';
 import { maxConfiguredRunnerTimeoutMs } from '../domain/runner-routing.js';
+import { isRunLeaseExpired } from './run-lease.js';
+import { processIdentityMatches } from '../lib/process-identity.js';
 import { createOutbox } from './outbox.js';
 import { createProjectionUpdater } from './projection-updater.js';
 import { createStaleRunReconciler } from './stale-run-reconciler.js';
@@ -14,14 +15,18 @@ export function createActiveRunRecovery(deps) {
         stateStore: deps.stateStore,
         projectionUpdater,
     });
-    async function isRunningRecordActive(record) {
-        const lock = await readFileLockStatus(deps.stateStore.paths.runnerLockFile, {
-            expectedCommandIncludes: process.argv[1] === undefined ? [] : [process.argv[1]],
-        });
-        if (!lock.active || lock.metadata === undefined) {
-            return false;
+    async function isRunningRecordActive(record, now) {
+        if (record.lease !== undefined && !isRunLeaseExpired(record, now)) {
+            return true;
         }
-        return Date.parse(lock.metadata.acquiredAt) <= Date.parse(record.startedAt);
+        return (processIdentityMatches({
+            pid: record.agentPid,
+            processStartedAt: record.agentProcessStartedAt,
+        }) ||
+            processIdentityMatches({
+                pid: record.workerPid,
+                processStartedAt: record.workerProcessStartedAt,
+            }));
     }
     const { reconcileStaleRunningRecords } = createStaleRunReconciler({
         config: deps.config,

package/dist/src/core/event-builders.js

@@ -29,6 +29,8 @@ function isFreshTriggeringComment(candidate) {
 export function createPublishIntentEvent(input) {
     const tokenCount = extractTokenCount(input.runnerResult.tokenUsage);
     const duration = formatDuration(input.startedAt, input.occurredAt);
+    const failureRepeated = input.runnerResult.failureClass !== undefined &&
+        input.previousFailureClass === input.runnerResult.failureClass;
     return createEventEnvelope({
         eventId: `${input.runId}-publish-intent`,
         workItemKey: input.projection.workItemKey,
@@ -107,6 +109,12 @@ export function createPublishIntentEvent(input) {
                 ? {}
                 : { cost: formatCostUsd(input.runnerResult.tokenUsage.costUsd) }),
             ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
+            idempotencyKey: `${input.runId}:result-comment`,
+            deliveryState: 'PENDING',
+            ...(failureRepeated ? { failureRepeated } : {}),
+            ...(input.previousFailureClass === undefined
+                ? {}
+                : { previousFailureClass: input.previousFailureClass }),
         },
         derivedHints: {
             stage: input.sentinel === 'DONE' ? 'done' : input.projection.wake.stage,
@@ -114,6 +122,7 @@ export function createPublishIntentEvent(input) {
     });
 }
 export function createLabelsEvent(input) {
+    const labelKind = input.statusLabel === 'wake:status.working' ? 'working-label' : 'completion-label';
     return createEventEnvelope({
         eventId: `${input.runId}-labels-${input.statusLabel.replace(/[^a-z0-9]+/gi, '-')}-${input.stageLabel.replace(/[^a-z0-9]+/gi, '-')}-${input.workflowLabel.replace(/[^a-z0-9]+/gi, '-')}`,
         workItemKey: input.projection.workItemKey,
@@ -134,6 +143,8 @@ export function createLabelsEvent(input) {
             stageLabel: input.stageLabel,
             workflowLabel: input.workflowLabel,
             origin: input.projection.origin ?? 'github',
+            idempotencyKey: `${input.runId}:${labelKind}`,
+            deliveryState: 'PENDING',
         },
     });
 }

package/dist/src/core/outbox.js

@@ -12,6 +12,10 @@ const outboundConfirmationEventTypes = new Set([
     'pr.comment.reply.published',
     'pr.review-comment.reply.published',
 ]);
+function intentId(event) {
+    const intentEventId = event.payload.intentEventId;
+    return typeof intentEventId === 'string' ? intentEventId : undefined;
+}
 // The outbox: outbound delivery (comments, labels) attempted independently of
 // run-outcome recording, with a durable, bounded retry trace. Extracted from
 // tick-runner.ts so it can be exercised in isolation; it has the cleanest
@@ -33,12 +37,60 @@ export function createOutbox(deps) {
             payload: {
                 intentEventId: intentEvent.eventId,
                 intentEventType: intentEvent.sourceEventType,
+                idempotencyKey: intentEvent.payload.idempotencyKey,
+                deliveryState: 'PENDING',
                 error: err instanceof Error ? err.message : String(err),
             },
         });
         await deps.stateStore.appendEventEnvelope(failureEvent);
         await deps.projectionUpdater.rebuildFromEvents([failureEvent]);
     }
+    async function recordSentUnconfirmed(intentEvent) {
+        const occurredAt = deps.clock.now().toISOString();
+        const sentEvent = createEventEnvelope({
+            eventId: `${intentEvent.eventId}-sent-unconfirmed-${randomUUID()}`,
+            workItemKey: intentEvent.workItemKey,
+            streamScope: 'work-item',
+            direction: 'internal',
+            sourceSystem: 'wake',
+            sourceEventType: 'wake.publish.sent-unconfirmed',
+            sourceRefs: intentEvent.sourceRefs,
+            occurredAt,
+            ingestedAt: occurredAt,
+            trigger: 'context-only',
+            payload: {
+                intentEventId: intentEvent.eventId,
+                intentEventType: intentEvent.sourceEventType,
+                idempotencyKey: intentEvent.payload.idempotencyKey,
+                deliveryState: 'SENT_UNCONFIRMED',
+            },
+        });
+        await deps.stateStore.appendEventEnvelope(sentEvent);
+        await deps.projectionUpdater.rebuildFromEvents([sentEvent]);
+    }
+    async function recordConfirmed(intentEvent, payload = {}) {
+        const confirmedAt = deps.clock.now().toISOString();
+        const confirmedEvent = createEventEnvelope({
+            eventId: `${intentEvent.eventId}-confirmed`,
+            workItemKey: intentEvent.workItemKey,
+            streamScope: 'work-item',
+            direction: 'internal',
+            sourceSystem: 'wake',
+            sourceEventType: 'wake.publish.confirmed',
+            sourceRefs: intentEvent.sourceRefs,
+            occurredAt: confirmedAt,
+            ingestedAt: confirmedAt,
+            trigger: 'context-only',
+            payload: {
+                intentEventId: intentEvent.eventId,
+                idempotencyKey: intentEvent.payload.idempotencyKey,
+                deliveryState: 'CONFIRMED',
+                ...payload,
+            },
+        });
+        const appended = await deps.stateStore.appendEventEnvelope(confirmedEvent);
+        await deps.projectionUpdater.rebuildFromEvents([appended]);
+    }
     // Outbound delivery (comments, labels) is attempted independently of run-outcome
     // recording: a delivery failure must never rewrite an already-recorded run result
     // (S1), and must always leave a durable, retryable trace instead of being lost
@@ -48,6 +100,7 @@ export function createOutbox(deps) {
             return;
         }
         try {
+            await recordSentUnconfirmed(event);
             const deliveryEvents = await deps.outboundSink.deliverIntent({ event });
             for (const deliveryEvent of deliveryEvents) {
                 await deps.stateStore.appendEventEnvelope(deliveryEvent);
@@ -57,21 +110,7 @@ export function createOutbox(deps) {
                 // No confirmation event was produced (e.g. a no-op label update) but the
                 // sink did not throw. Record that delivery was attempted successfully so
                 // the outbox scan below does not retry it indefinitely.
-                const confirmedAt = deps.clock.now().toISOString();
-                const confirmedEvent = createEventEnvelope({
-                    eventId: `${event.eventId}-confirmed`,
-                    workItemKey: event.workItemKey,
-                    streamScope: 'work-item',
-                    direction: 'internal',
-                    sourceSystem: 'wake',
-                    sourceEventType: 'wake.publish.confirmed',
-                    sourceRefs: event.sourceRefs,
-                    occurredAt: confirmedAt,
-                    ingestedAt: confirmedAt,
-                    trigger: 'context-only',
-                    payload: { intentEventId: event.eventId },
-                });
-                await deps.stateStore.appendEventEnvelope(confirmedEvent);
+                await recordConfirmed(event);
             }
         }
         catch (err) {
@@ -83,6 +122,18 @@ export function createOutbox(deps) {
         await deps.projectionUpdater.rebuildFromEvents([event]);
         await attemptDelivery(event);
     }
+    async function suppressOutboundEvent(event, input) {
+        const suppressedEvent = await deps.stateStore.appendEventEnvelope({
+            ...event,
+            payload: {
+                ...event.payload,
+                deliveryState: 'CONFIRMED',
+                suppressedPublishReason: input.suppressedPublishReason,
+            },
+        });
+        await deps.projectionUpdater.rebuildFromEvents([suppressedEvent]);
+        await recordConfirmed(event, { suppressedPublishReason: input.suppressedPublishReason });
+    }
     // Adopts the outbox pattern: an intent is only considered delivered once a
     // matching confirmation event exists. Anything left unconfirmed by a prior tick
     // (e.g. the process crashed mid-delivery) is retried here, bounded so a
@@ -94,9 +145,10 @@ export function createOutbox(deps) {
         const events = await deps.stateStore.listEventEnvelopes();
         const confirmedIntentIds = new Set();
         const failureAttempts = new Map();
+        const uncertainIntentIds = new Set();
         for (const event of events) {
-            const intentEventId = event.payload.intentEventId;
-            if (typeof intentEventId !== 'string') {
+            const intentEventId = intentId(event);
+            if (intentEventId === undefined) {
                 continue;
             }
             if (outboundConfirmationEventTypes.has(event.sourceEventType)) {
@@ -105,6 +157,9 @@ export function createOutbox(deps) {
             if (event.sourceEventType === 'wake.publish.failed') {
                 failureAttempts.set(intentEventId, (failureAttempts.get(intentEventId) ?? 0) + 1);
             }
+            if (event.sourceEventType === 'wake.publish.sent-unconfirmed') {
+                uncertainIntentIds.add(intentEventId);
+            }
         }
         for (const intent of events) {
             if (!outboundIntentEventTypes.has(intent.sourceEventType)) {
@@ -116,8 +171,30 @@ export function createOutbox(deps) {
             if ((failureAttempts.get(intent.eventId) ?? 0) >= outboxMaxAttempts) {
                 continue;
             }
+            if (uncertainIntentIds.has(intent.eventId) &&
+                deps.outboundSink.reconcileIntent !== undefined) {
+                try {
+                    const reconciledEvents = await deps.outboundSink.reconcileIntent({ event: intent });
+                    for (const reconciledEvent of reconciledEvents) {
+                        await deps.stateStore.appendEventEnvelope(reconciledEvent);
+                    }
+                    await deps.projectionUpdater.rebuildFromEvents(reconciledEvents);
+                    if (reconciledEvents.length > 0) {
+                        continue;
+                    }
+                }
+                catch (err) {
+                    await recordDeliveryFailure(intent, err);
+                    continue;
+                }
+            }
             await attemptDelivery(intent);
         }
     }
-    return { attemptDelivery, deliverOutboundEvent, retryUnconfirmedDeliveries };
+    return {
+        attemptDelivery,
+        deliverOutboundEvent,
+        retryUnconfirmedDeliveries,
+        suppressOutboundEvent,
+    };
 }

package/dist/src/core/run-lease.js

@@ -0,0 +1,38 @@
+import { randomUUID } from 'node:crypto';
+export const runLeaseDurationMs = 60_000;
+export const runLeaseRenewalIntervalMs = 20_000;
+export function createRunLease(input) {
+    const acquiredAt = input.clock.now();
+    const expiresAt = new Date(acquiredAt.getTime() + runLeaseDurationMs);
+    return {
+        leaseId: `lease-${randomUUID()}`,
+        ownerInstanceId: input.ownerInstanceId,
+        acquiredAt: acquiredAt.toISOString(),
+        lastRenewedAt: acquiredAt.toISOString(),
+        expiresAt: expiresAt.toISOString(),
+    };
+}
+export function isRunLeaseExpired(record, now) {
+    if (record.lease === undefined) {
+        return true;
+    }
+    return Date.parse(record.lease.expiresAt) <= now.getTime();
+}
+export async function renewRunLease(input) {
+    const now = input.clock.now();
+    const renewed = await input.stateStore.updateRunRecordIf(input.runId, {
+        expect: (record) => record.status === 'running' &&
+            record.lifecycle !== 'TERMINAL' &&
+            record.lease?.leaseId === input.leaseId &&
+            record.lease.ownerInstanceId === input.ownerInstanceId,
+        update: (record) => ({
+            ...record,
+            lease: {
+                ...record.lease,
+                lastRenewedAt: now.toISOString(),
+                expiresAt: new Date(now.getTime() + runLeaseDurationMs).toISOString(),
+            },
+        }),
+    });
+    return renewed !== null;
+}

package/dist/src/core/sink-router.js

@@ -38,36 +38,34 @@ function withSinkRef(event, sink) {
         },
     };
 }
+function targetSinksForEvent(input) {
+    const targetSinks = new Set();
+    const origin = typeof input.event.payload.origin === 'string' ? input.event.payload.origin : undefined;
+    const sourceOrigin = input.event.sourceRefs.sink ?? origin;
+    if (input.event.sourceEventType === 'wake.labels.requested') {
+        const projectionOrigin = typeof input.event.payload.origin === 'string' ? input.event.payload.origin : undefined;
+        if (projectionOrigin !== undefined) {
+            targetSinks.add(projectionOrigin);
+        }
+    }
+    const resourceUri = input.event.sourceRefs.resourceUri;
+    if (input.event.sourceEventType === 'wake.publish.intent.requested' &&
+        sourceOrigin !== undefined) {
+        const resourceSink = resourceUri === undefined ? sourceOrigin : sinkNameForResourceUri(resourceUri, sourceOrigin);
+        targetSinks.add(input.sinksByName.has(resourceSink) ? resourceSink : sourceOrigin);
+    }
+    for (const [sinkName, sinkConfig] of Object.entries(input.config.sinks ?? {})) {
+        if (sinkConfig.subscribe.some((subscription) => subscriptionMatches(input.event, subscription))) {
+            targetSinks.add(sinkName);
+        }
+    }
+    return targetSinks;
+}
 export function createOutboundSinkRouter(input) {
     const sinksByName = new Map(input.sinks.map((sink) => [sink.sink, sink]));
     return {
         async deliverIntent({ event }) {
-            const targetSinks = new Set();
-            const origin = typeof event.payload.origin === 'string' ? event.payload.origin : undefined;
-            const sourceOrigin = event.sourceRefs.sink ?? origin;
-            if (event.sourceEventType === 'wake.labels.requested') {
-                const projectionOrigin = typeof event.payload.origin === 'string' ? event.payload.origin : undefined;
-                if (projectionOrigin !== undefined) {
-                    targetSinks.add(projectionOrigin);
-                }
-            }
-            const resourceUri = event.sourceRefs.resourceUri;
-            if (event.sourceEventType === 'wake.publish.intent.requested' && sourceOrigin !== undefined) {
-                const resourceSink = resourceUri === undefined
-                    ? sourceOrigin
-                    : sinkNameForResourceUri(resourceUri, sourceOrigin);
-                // A resource-derived sink name (e.g. a PR surface) may not be
-                // registered — the source that owns it can be disabled independently
-                // of the origin sink. Falling back to sourceOrigin here, rather than
-                // silently skipping an unregistered sink below, is what keeps a reply
-                // from being dropped-but-marked-delivered when that happens.
-                targetSinks.add(sinksByName.has(resourceSink) ? resourceSink : sourceOrigin);
-            }
-            for (const [sinkName, sinkConfig] of Object.entries(input.config.sinks ?? {})) {
-                if (sinkConfig.subscribe.some((subscription) => subscriptionMatches(event, subscription))) {
-                    targetSinks.add(sinkName);
-                }
-            }
+            const targetSinks = targetSinksForEvent({ event, sinksByName, config: input.config });
             const deliveryEvents = [];
             for (const sinkName of targetSinks) {
                 const sink = sinksByName.get(sinkName);
@@ -79,5 +77,18 @@ export function createOutboundSinkRouter(input) {
             }
             return deliveryEvents;
         },
+        async reconcileIntent({ event }) {
+            const targetSinks = targetSinksForEvent({ event, sinksByName, config: input.config });
+            const deliveryEvents = [];
+            for (const sinkName of targetSinks) {
+                const sink = sinksByName.get(sinkName);
+                if (sink?.reconcileIntent === undefined) {
+                    continue;
+                }
+                const sinkDeliveryEvents = await sink.reconcileIntent({ event });
+                deliveryEvents.push(...sinkDeliveryEvents.map((deliveryEvent) => withSinkRef(deliveryEvent, sinkName)));
+            }
+            return deliveryEvents;
+        },
     };
 }

package/dist/src/core/stale-run-reconciler.js

@@ -44,13 +44,9 @@ export function createStaleRunReconciler(deps) {
             }
             return 'startup-recovery';
         }
-        const active = await deps.isRunningRecordActive(record);
+        const active = await deps.isRunningRecordActive(record, now);
         if (active) {
-            const startedAtMs = Date.parse(record.startedAt);
-            if (!Number.isFinite(startedAtMs)) {
-                return 'timeout';
-            }
-            return now.getTime() - startedAtMs >= deps.runnerTimeoutMs() ? 'timeout' : null;
+            return null;
         }
         if (record.lifecycle === 'RUNNING' || record.lifecycle === 'PROCESS_STARTING') {
             return 'runner-lock-not-active';

package/dist/src/core/tick-runner.js

@@ -1,7 +1,7 @@
 import { createLifecycleService } from './lifecycle-service.js';
 import { createPolicyEngine } from './policy-engine.js';
 import { createProjectionUpdater } from './projection-updater.js';
-import { acquireFileLock, readFileLockStatus } from '../lib/lock.js';
+import { acquireFileLock } from '../lib/lock.js';
 import { CORRELATION_REGISTERED_EVENT, parseRunnerArtifacts, parseRunnerResult, } from '../domain/schema.js';
 import { maxConfiguredRunnerTimeoutMs, resolveRunnerRouting } from '../domain/runner-routing.js';
 import { awaitingApprovalRunnerSentinel, stageLabelForStage } from '../domain/stages.js';
@@ -15,6 +15,8 @@ import { createOutbox } from './outbox.js';
 import { createEventResolver } from './event-resolver.js';
 import { createStaleRunReconciler } from './stale-run-reconciler.js';
 import { createWorkspaceCleanup } from './workspace-cleanup.js';
+import { createRunLease, isRunLeaseExpired, renewRunLease, runLeaseRenewalIntervalMs, } from './run-lease.js';
+import { currentProcessIdentity, processIdentityMatches } from '../lib/process-identity.js';
 function latestHumanCommentId(candidate) {
     const human = candidate.comments.filter((c) => !c.isBotAuthored);
     return human.at(-1)?.id;
@@ -39,7 +41,7 @@ export function createTickRunner(deps) {
         resourceIndex: deps.resourceIndex,
         config: deps.config,
     });
-    const { deliverOutboundEvent, retryUnconfirmedDeliveries } = createOutbox({
+    const { deliverOutboundEvent, retryUnconfirmedDeliveries, suppressOutboundEvent } = createOutbox({
         clock: deps.clock,
         stateStore: deps.stateStore,
         projectionUpdater,
@@ -68,6 +70,7 @@ export function createTickRunner(deps) {
         workspaceManager: deps.workspaceManager,
         projectionUpdater,
     });
+    const ownerInstanceId = `instance-${process.pid}-${Date.now()}`;
     function isAwaitingApproval(projection) {
         return projection.context.lastRunSentinel === awaitingApprovalRunnerSentinel;
     }
@@ -134,6 +137,7 @@ export function createTickRunner(deps) {
                     relation: 'primary',
                     provenance: 'agent-reported',
                     registeredBy: input.runId,
+                    idempotencyKey: `${input.runId}:artifact-registration:${verified.resourceUri}`,
                 },
             });
             const appended = await deps.stateStore.appendEventEnvelope(event);
@@ -204,14 +208,18 @@ export function createTickRunner(deps) {
     function runnerTimeoutMs() {
         return maxConfiguredRunnerTimeoutMs(deps.config);
     }
-    async function isRunningRecordActive(record) {
-        const lock = await readFileLockStatus(deps.stateStore.paths.runnerLockFile, {
-            expectedCommandIncludes: process.argv[1] === undefined ? [] : [process.argv[1]],
-        });
-        if (!lock.active || lock.metadata === undefined) {
-            return false;
+    async function isRunningRecordActive(record, now) {
+        if (record.lease !== undefined && !isRunLeaseExpired(record, now)) {
+            return true;
         }
-        return Date.parse(lock.metadata.acquiredAt) <= Date.parse(record.startedAt);
+        return (processIdentityMatches({
+            pid: record.agentPid,
+            processStartedAt: record.agentProcessStartedAt,
+        }) ||
+            processIdentityMatches({
+                pid: record.workerPid,
+                processStartedAt: record.workerProcessStartedAt,
+            }));
     }
     async function parkConfigDriftedProjections(projections) {
         let parked = false;
@@ -289,9 +297,7 @@ export function createTickRunner(deps) {
         }
     }
     async function runRunnerTick() {
-        const lock = await acquireFileLock(deps.stateStore.paths.runnerLockFile, {
-            staleAfterMs: runnerTimeoutMs(),
-        });
+        const lock = await acquireFileLock(deps.stateStore.paths.runnerLockFile);
         if (!lock.acquired) {
             return { status: 'locked' };
         }
@@ -439,6 +445,8 @@ export function createTickRunner(deps) {
                 return { status: 'idle' };
             }
             const runId = `run-${candidate.issue.number}-${deps.clock.now().getTime()}`;
+            const lease = createRunLease({ clock: deps.clock, ownerInstanceId });
+            const workerIdentity = currentProcessIdentity();
             const runningRecord = {
                 schemaVersion: 1,
                 runId,
@@ -450,6 +458,9 @@ export function createTickRunner(deps) {
                 status: 'running',
                 startedAt: nowIso,
                 routing,
+                lease,
+                workerPid: workerIdentity.pid,
+                workerProcessStartedAt: workerIdentity.processStartedAt,
             };
             await deps.stateStore.writeRunRecord(runningRecord);
             async function transitionRunLifecycle(lifecycle) {
@@ -491,6 +502,18 @@ export function createTickRunner(deps) {
                 workflowLabel: workflowLabelForWorkflowName(workflowName),
                 occurredAt: eventStampNow(),
             }));
+            let leaseRenewalTimer;
+            function startLeaseRenewal() {
+                leaseRenewalTimer = setInterval(() => {
+                    void renewRunLease({
+                        stateStore: deps.stateStore,
+                        runId,
+                        leaseId: lease.leaseId,
+                        ownerInstanceId,
+                        clock: deps.clock,
+                    });
+                }, runLeaseRenewalIntervalMs);
+            }
             try {
                 await transitionRunLifecycle('PREPARING');
                 const prepareResult = workspaceMode === 'branch'
@@ -521,6 +544,7 @@ export function createTickRunner(deps) {
                 });
                 const recentEvents = await deps.stateStore.listEventEnvelopesForWorkItem(candidate.workItemKey, 6);
                 await transitionRunLifecycle('RUNNING');
+                startLeaseRenewal();
                 const runnerResult = await deps.runner.run({
                     action,
                     projection: candidate,
@@ -532,7 +556,21 @@ export function createTickRunner(deps) {
                     ...(workspacePath === undefined ? {} : { workspacePath }),
                     ...(mergeConflictDetected ? { mergeConflictDetected: true } : {}),
                     ...(upstreamChanges === undefined ? {} : { upstreamChanges }),
+                    onProcessStart: async (identity) => {
+                        await deps.stateStore.updateRunRecordIf(runId, {
+                            expect: (record) => record.status === 'running' &&
+                                record.lease?.leaseId === lease.leaseId &&
+                                record.lease.ownerInstanceId === ownerInstanceId,
+                            update: (record) => ({
+                                ...record,
+                                agentPid: identity.pid,
+                                agentProcessStartedAt: identity.processStartedAt,
+                            }),
+                        });
+                    },
                 });
+                clearInterval(leaseRenewalTimer);
+                leaseRenewalTimer = undefined;
                 const parsedRunnerResult = parseRunnerResult(runnerResult.result);
                 const rawSentinel = parsedRunnerResult.status;
                 // Coerce DONE → AWAITING_APPROVAL when the stage requires human sign-off.
@@ -684,23 +722,31 @@ export function createTickRunner(deps) {
                     workflowLabel: workflowLabelForWorkflowName(workflowName),
                     occurredAt: finishedAt,
                 }));
+                const publishIntent = createPublishIntentEvent({
+                    projection: candidate,
+                    runId,
+                    action,
+                    runnerResult,
+                    parsedRunnerResult,
+                    sentinel,
+                    occurredAt: finishedAt,
+                    startedAt: nowIso,
+                    ...(workspacePath === undefined ? {} : { workspacePath }),
+                    ...(typeof candidate.context.lastFailureClass === 'string'
+                        ? { previousFailureClass: candidate.context.lastFailureClass }
+                        : {}),
+                });
                 if (shouldPublishRunResult({
                     failureClass: runnerResult.failureClass,
                     previousFailureClass: candidate.context.lastFailureClass,
                 })) {
-                    const publishIntent = createPublishIntentEvent({
-                        projection: candidate,
-                        runId,
-                        action,
-                        runnerResult,
-                        parsedRunnerResult,
-                        sentinel,
-                        occurredAt: finishedAt,
-                        startedAt: nowIso,
-                        ...(workspacePath === undefined ? {} : { workspacePath }),
-                    });
                     await deliverOutboundEvent(publishIntent);
                 }
+                else {
+                    await suppressOutboundEvent(publishIntent, {
+                        suppressedPublishReason: runnerResult.failureClass === 'quota' ? 'quota-failure' : 'repeated-infra-failure',
+                    });
+                }
                 return {
                     status: 'processed',
                     runId,
@@ -709,6 +755,7 @@ export function createTickRunner(deps) {
                 };
             }
             catch (err) {
+                clearInterval(leaseRenewalTimer);
                 const finishedAt = deps.clock.now().toISOString();
                 const sentinel = 'FAILED';
                 const failedRecord = (await deps.stateStore.readRunRecord(runId)) ?? runningRecord;
@@ -767,6 +814,7 @@ export function createTickRunner(deps) {
                     result: errorMessage,
                     model: 'unknown',
                     cli: 'unknown',
+                    failureClass: 'infra',
                 };
                 const parsedInfraFailureResult = parseRunnerResult(infraFailureResult.result);
                 const failurePublishIntent = createPublishIntentEvent({
@@ -778,6 +826,9 @@ export function createTickRunner(deps) {
                     sentinel,
                     occurredAt: finishedAt,
                     startedAt: nowIso,
+                    ...(typeof candidate.context.lastFailureClass === 'string'
+                        ? { previousFailureClass: candidate.context.lastFailureClass }
+                        : {}),
                 });
                 if (shouldPublishRunResult({
                     failureClass: 'infra',
@@ -785,6 +836,11 @@ export function createTickRunner(deps) {
                 })) {
                     await deliverOutboundEvent(failurePublishIntent);
                 }
+                else {
+                    await suppressOutboundEvent(failurePublishIntent, {
+                        suppressedPublishReason: 'repeated-infra-failure',
+                    });
+                }
                 return {
                     status: 'processed',
                     runId,

package/dist/src/domain/schema.js

@@ -301,6 +301,13 @@ const runTokenUsageSchema = z.object({
     costUsd: z.number().nonnegative().optional(),
     turns: z.number().nonnegative().optional(),
 });
+const runLeaseSchema = z.object({
+    leaseId: z.string(),
+    ownerInstanceId: z.string(),
+    acquiredAt: isoTimestampSchema,
+    lastRenewedAt: isoTimestampSchema,
+    expiresAt: isoTimestampSchema,
+});
 function legacyRunLifecycle(input) {
     if (input.lifecycle !== undefined) {
         return input;
@@ -346,6 +353,11 @@ export const runRecordSchema = z.preprocess((input) => {
     workflowOutcome: workflowOutcomeSchema.optional(),
     summary: z.string().optional(),
     routing: runnerRoutingSchema.optional(),
+    lease: runLeaseSchema.optional(),
+    workerPid: z.number().int().positive().optional(),
+    workerProcessStartedAt: z.string().optional(),
+    agentPid: z.number().int().positive().optional(),
+    agentProcessStartedAt: z.string().optional(),
     tokenUsage: runTokenUsageSchema.optional(),
     metadata: z.record(z.string(), z.unknown()).optional(),
 }));

package/dist/src/lib/lock.js

@@ -156,11 +156,11 @@ export async function acquireFileLock(path, options) {
     }
     catch (error) {
         if (error.code === 'EEXIST') {
-            if (options?.staleAfterMs !== undefined &&
-                !(await readFileLockStatus(path, {
-                    staleAfterMs: options.staleAfterMs,
-                    now: options.now ?? new Date(),
-                })).active) {
+            const status = await readFileLockStatus(path, {
+                ...(options?.staleAfterMs === undefined ? {} : { staleAfterMs: options.staleAfterMs }),
+                now: options?.now ?? new Date(),
+            });
+            if (!status.active) {
                 await rm(path, { force: true });
                 try {
                     return await tryAcquire();

package/dist/src/lib/process-identity.js

@@ -0,0 +1,54 @@
+import { readFileSync } from 'node:fs';
+const currentProcessStartedAt = new Date(Date.now() - process.uptime() * 1000).toISOString();
+function readLinuxProcessStartTicks(pid) {
+    try {
+        const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
+        const endCommand = stat.lastIndexOf(')');
+        if (endCommand === -1) {
+            return undefined;
+        }
+        const fields = stat
+            .slice(endCommand + 2)
+            .trim()
+            .split(/\s+/);
+        const startTicks = fields[19];
+        return startTicks === undefined ? undefined : `linux-start-ticks:${startTicks}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readProcessIdentity(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return null;
+    }
+    try {
+        process.kill(pid, 0);
+    }
+    catch (error) {
+        if (error.code === 'ESRCH') {
+            return null;
+        }
+    }
+    const linuxStartedAt = readLinuxProcessStartTicks(pid);
+    if (linuxStartedAt !== undefined) {
+        return { pid, processStartedAt: linuxStartedAt };
+    }
+    if (pid === process.pid) {
+        return { pid, processStartedAt: currentProcessStartedAt };
+    }
+    return null;
+}
+export function currentProcessIdentity() {
+    return (readProcessIdentity(process.pid) ?? {
+        pid: process.pid,
+        processStartedAt: currentProcessStartedAt,
+    });
+}
+export function processIdentityMatches(input) {
+    if (input.pid === undefined || input.processStartedAt === undefined) {
+        return false;
+    }
+    const current = readProcessIdentity(input.pid);
+    return current?.processStartedAt === input.processStartedAt;
+}

package/dist/src/version.js

@@ -124,4 +124,4 @@ export function resolveWakeVersion(options = {}) {
     }
     return '0.1.0-dev';
 }
-export const wakeVersion = "gf58d7a3";
+export const wakeVersion = "g18ca5a7";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.2.29",
+  "version": "0.2.31",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {