feat(daemon): add correlated prompt lifecycles

Closes #3

Author: rynfar

.pylon/features.yaml

@@ -76,6 +76,27 @@ decisions:
     revisit_when:
       - Prime publishes list, correlation, cancellation, and terminal lifecycle events.
 
+
+  correlated-prompt-lifecycle:
+    area: prompt-ownership
+    state: candidate
+    owner: shared
+    decision: hybridize
+    pylon_refs:
+      - https://github.com/pylon-code/prime-agent/issues/3
+      - https://github.com/pylon-code/prime-agent/pull/9
+      - https://github.com/pylon-code/pylon/issues/114
+    upstream_refs:
+      - https://github.com/PrimeIntellect-ai/prime-agent/pull/800
+      - https://github.com/PrimeIntellect-ai/prime-agent/pull/1239
+      - https://github.com/PrimeIntellect-ai/prime-agent/pull/1859
+      - https://github.com/PrimeIntellect-ai/prime-agent/pull/1861
+    fork_change: negotiated-correlated-prompt-lifecycle-v1
+    upstream_support: Prime has queue, background, cancellation, reconnect, and event primitives, but no optional contract proving per-prompt ownership, delivery, provenance, terminal usage, and durable generation-scoped recovery together.
+    revisit_when:
+      - Prime upstream ships an equivalent negotiated lifecycle with exact delivery, provenance, scoped cancellation, recovery, and per-prompt usage guarantees.
+      - Pylon can remove the fork contract without weakening stock-Prime fallback behavior.
+
   heartbeat-projection:
     area: autonomous-work
     state: blocked

.pylon/upstream-review.md

@@ -34,3 +34,14 @@ This ledger records Prime upstream evidence and the decision taken for each over
 - `kernel-protocol-test-fixtures`: **adopt** the exact three-line repair from open Prime PR #1886 at `a97f6995d39f2cccbd33123ab246f9786fc8ac13`. Preserve that upstream commit as a merge parent rather than creating Pylon-specific behavior.
 - Validation: the focused Prime Inference catalog test passed all 12 cases; the two protocol fixture suites passed all 39 cases; `npm run check` passed Biome over 937 files, the TypeScript check, installer rendering, and the browser smoke check; `git diff --check` passed.
 - Revisit when Prime adopts deterministic catalog fixtures or repo-owned structural invariants, or stops regenerating vendor pricing before tests and releases.
+
+## 2026-08-29 — correlated prompt lifecycle candidate
+
+- Upstream baseline: `PrimeIntellect-ai/prime-agent@d60fab8a76d9c169f945341f0ee3bde21903bb55`; latest audited release remains `v0.8.1`.
+- Reviewed Prime PRs #800, #1239, #1859, and #1861 plus the current daemon prompt, queue, cancellation, compact stream, worker recovery, update restart, and agent-connection paths. These changes provide useful primitives but no single optional contract proves exact per-prompt ownership, delivery, provenance, scoped cancellation, reconnect/recovery, generation fencing, request identity, and terminal usage.
+- `correlated-prompt-lifecycle`: **hybridize**. Retain Prime's existing session and queue machinery behind Pylon's optional `correlated_prompt_lifecycle_v1` daemon/client capability. Keep protocol version 7, use additive schema revision 24, keep the capability out of default and required client capability sets, and shape lifecycle/provenance only for clients that explicitly negotiate it.
+- The fork candidate adds dedicated correlated submit, cancel, and read-only lifecycle commands; exact session-generation fencing; canonical request fingerprints and conflicting retry rejection; durable command and worker recovery; delivery-aware cancellation; bounded lifecycle records/tombstones; prompt or session event provenance; per-prompt terminal usage; and fail-closed reconnect, replacement, and recovery validation. Stock clients and daemons retain their legacy prompt behavior.
+- Replacement and reload are fenced at the session runtime boundary while any correlated lifecycle is nonterminal. Worker recovery replays only queued or selected actions; preparation that may already have run arbitrary extension hooks is terminalized as failed instead of being replayed.
+- Fork candidate: [pylon-code/prime-agent#9](https://github.com/pylon-code/prime-agent/pull/9).
+- Validation: the post-rebase lifecycle, connection, supervisor, runtime, recovery, and ledger checkpoint passed 564 tests across 17 files. The final changed-boundary checkpoint passed 202 connection and supervisor-monitor tests; the clean supervisor process checkpoint passed 10 tests with 8 fixture-gated skips. `npm run check` passed Biome over 940 files, TypeScript, installer rendering, and browser smoke; `git diff --check` passed. Independent final and follow-up audits found no remaining P0 or P1 findings.
+- Revisit when Prime upstream ships an explicitly negotiated equivalent with the same delivery, provenance, scoped cancellation, recovery, generation, retry-integrity, privacy, and per-prompt usage guarantees.

packages/coding-agent/.changes/correlated-prompt-lifecycle.md

@@ -0,0 +1 @@
+- Added optional correlated prompt lifecycle tracking and event provenance for capable daemon clients.

packages/coding-agent/src/core/agent-session-runtime.ts

@@ -68,6 +68,7 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {
 	private beforeSessionInvalidate?: () => void;
 	private subagentRuntimeHost?: SubagentRuntimeHost;
 	private subagentRuntimes = new Map<string, AgentSessionRuntime>();
+	private sessionReplacementInProgress = false;
 	private disposePromise?: Promise<void>;
 
 	constructor(
@@ -208,6 +209,7 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {
 
 	private bindRuntimeHost(): void {
 		this._session.setSubagentRuntimeHost(this.subagentRuntimeHost ?? this);
+		this._session.setSessionReplacementAdmissionGuard(() => this.sessionReplacementInProgress);
 	}
 
 	private apply(result: CreateAgentSessionRuntimeResult): void {
@@ -389,6 +391,20 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {
 		}
 	}
 
+	private async withSessionReplacementFence<T>(operation: () => Promise<T>): Promise<T> {
+		if (this.sessionReplacementInProgress) {
+			throw new Error("A session replacement or reload is already in progress");
+		}
+		const release = this.session.acquireSessionReplacementFence();
+		this.sessionReplacementInProgress = true;
+		try {
+			return await operation();
+		} finally {
+			this.sessionReplacementInProgress = false;
+			release();
+		}
+	}
+
 	private async finishSessionReplacement(withSession?: (ctx: ReplacedSessionContext) => Promise<void>): Promise<void> {
 		if (this.rebindSession) {
 			await this.rebindSession(this.session);
@@ -407,6 +423,16 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {
 			cwdOverride?: string;
 			withSession?: (ctx: ReplacedSessionContext) => Promise<void>;
 		},
+	): Promise<{ cancelled: boolean }> {
+		return this.withSessionReplacementFence(() => this.switchSessionUnfenced(sessionPath, options));
+	}
+
+	private async switchSessionUnfenced(
+		sessionPath: string,
+		options?: {
+			cwdOverride?: string;
+			withSession?: (ctx: ReplacedSessionContext) => Promise<void>;
+		},
 	): Promise<{ cancelled: boolean }> {
 		const beforeResult = await this.emitBeforeSwitch("resume", sessionPath);
 		if (beforeResult.cancelled) {
@@ -449,6 +475,14 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {
 		parentSession?: string;
 		setup?: (sessionManager: SessionManager) => Promise<void>;
 		withSession?: (ctx: ReplacedSessionContext) => Promise<void>;
+	}): Promise<{ cancelled: boolean }> {
+		return this.withSessionReplacementFence(() => this.newSessionUnfenced(options));
+	}
+
+	private async newSessionUnfenced(options?: {
+		parentSession?: string;
+		setup?: (sessionManager: SessionManager) => Promise<void>;
+		withSession?: (ctx: ReplacedSessionContext) => Promise<void>;
 	}): Promise<{ cancelled: boolean }> {
 		const beforeResult = await this.emitBeforeSwitch("new");
 		if (beforeResult.cancelled) {
@@ -498,6 +532,16 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {
 			position?: "before" | "at";
 			withSession?: (ctx: ReplacedSessionContext) => Promise<void>;
 		},
+	): Promise<{ cancelled: boolean; selectedText?: string }> {
+		return this.withSessionReplacementFence(() => this.forkUnfenced(entryId, options));
+	}
+
+	private async forkUnfenced(
+		entryId: string,
+		options?: {
+			position?: "before" | "at";
+			withSession?: (ctx: ReplacedSessionContext) => Promise<void>;
+		},
 	): Promise<{ cancelled: boolean; selectedText?: string }> {
 		const position = options?.position ?? "before";
 		const beforeResult = await this.emitBeforeFork(entryId, { position });
@@ -629,6 +673,10 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {
 	 * @throws {MissingSessionCwdError} When the imported session cwd cannot be resolved and no override is provided.
 	 */
 	async importFromJsonl(inputPath: string, cwdOverride?: string): Promise<{ cancelled: boolean }> {
+		return this.withSessionReplacementFence(() => this.importFromJsonlUnfenced(inputPath, cwdOverride));
+	}
+
+	private async importFromJsonlUnfenced(inputPath: string, cwdOverride?: string): Promise<{ cancelled: boolean }> {
 		const resolvedPath = resolve(inputPath);
 		if (!existsSync(resolvedPath)) {
 			throw new SessionImportFileNotFoundError(resolvedPath);