@themoltnet/agent-daemon 0.32.0 → 0.32.2

package/dist/main.js

@@ -12,8 +12,9 @@ import { parseArgs, promisify } from "node:util";
 import { AgentRuntime, ApiTaskReporter, ApiTaskSource, PollingApiTaskSource } from "@themoltnet/agent-runtime";
 import { createPiRetryTriage, createPiTaskExecutor, findMainWorktree, normalizeRetryTriageResult, redactRetryTriageSecrets } from "@themoltnet/pi-extension";
 import { execFile, execFileSync } from "node:child_process";
-import { accessSync, constants, createReadStream, createWriteStream, existsSync, mkdirSync, readdirSync } from "node:fs";
+import { accessSync, constants, createReadStream, createWriteStream, existsSync, mkdirSync, readdirSync, realpathSync, rmSync } from "node:fs";
 import { AuthenticationError, MoltNetError, connect } from "@themoltnet/sdk";
+import { createHash, randomUUID } from "node:crypto";
 import { once } from "node:events";
 import { pino, transport } from "pino";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
@@ -25,7 +26,6 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { getModel } from "@earendil-works/pi-ai";
 import { mkdir, realpath, stat } from "node:fs/promises";
 import { pipeline } from "node:stream/promises";
-import { createHash } from "node:crypto";
 import { Writable } from "node:stream";
 import { createGzip } from "node:zlib";
 //#region ../../libs/observability/src/instrumentation.ts
@@ -4454,6 +4454,875 @@ function deepFreeze(value) {
 deepFreeze(RUNTIME_PROFILE_CONTEXT_CATALOGUE);
 Object.freeze(Object.keys(RUNTIME_PROFILE_CONTEXT_CATALOGUE.recipes));
 //#endregion
+//#region ../../libs/models/src/preview-sign.ts
+function schemaRef$1(schema, id) {
+	return Unsafe(Ref$1(id));
+}
+var PreviewSignBase64UrlSchema = String$1({
+	$id: "PreviewSignBase64Url",
+	minLength: 1,
+	maxLength: 5462,
+	pattern: "^[A-Za-z0-9_-]+$"
+});
+var PreviewSignSha256Base64UrlSchema = String$1({
+	$id: "PreviewSignSha256Base64Url",
+	minLength: 43,
+	maxLength: 43,
+	pattern: "^[A-Za-z0-9_-]+$"
+});
+var PreviewSignP256DerSignatureBase64UrlSchema = String$1({
+	$id: "PreviewSignP256DerSignatureBase64Url",
+	minLength: 11,
+	maxLength: 96,
+	pattern: "^[A-Za-z0-9_-]+$"
+});
+var PreviewSignEs256PublicKeySchema = _Object_({
+	kty: Literal(2),
+	algorithm: Literal(-7),
+	curve: Literal(1),
+	x: schemaRef$1(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url"),
+	y: schemaRef$1(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url")
+}, {
+	$id: "PreviewSignEs256PublicKey",
+	additionalProperties: false
+});
+var PreviewSignEcdhEsHkdf256PublicKeySchema = _Object_({
+	kty: Literal(2),
+	algorithm: Literal(-25),
+	curve: Literal(1),
+	x: schemaRef$1(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url"),
+	y: schemaRef$1(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url")
+}, {
+	$id: "PreviewSignEcdhEsHkdf256PublicKey",
+	additionalProperties: false
+});
+var PreviewSignEsp256PublicKeySchema = _Object_({
+	kty: Literal(2),
+	algorithm: Literal(-9),
+	curve: Literal(1),
+	x: schemaRef$1(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url"),
+	y: schemaRef$1(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url")
+}, {
+	$id: "PreviewSignEsp256PublicKey",
+	additionalProperties: false
+});
+var PreviewSignArkgSeedPublicKeySchema = _Object_({
+	kty: Literal(-65537),
+	algorithm: Literal(-65700),
+	derivedAlgorithm: Literal(-9),
+	blindingKey: schemaRef$1(PreviewSignEs256PublicKeySchema, "PreviewSignEs256PublicKey"),
+	kemKey: schemaRef$1(PreviewSignEcdhEsHkdf256PublicKeySchema, "PreviewSignEcdhEsHkdf256PublicKey")
+}, {
+	$id: "PreviewSignArkgSeedPublicKey",
+	additionalProperties: false
+});
+var PreviewSignPublicMaterialSchema = _Object_({
+	version: Literal(1),
+	outerCredentialId: schemaRef$1(PreviewSignBase64UrlSchema, "PreviewSignBase64Url"),
+	outerPublicKey: schemaRef$1(PreviewSignEs256PublicKeySchema, "PreviewSignEs256PublicKey"),
+	previewKeyHandle: schemaRef$1(PreviewSignBase64UrlSchema, "PreviewSignBase64Url"),
+	seedPublicKey: schemaRef$1(PreviewSignArkgSeedPublicKeySchema, "PreviewSignArkgSeedPublicKey")
+}, {
+	$id: "PreviewSignPublicMaterial",
+	additionalProperties: false
+});
+var PreviewSignChallengeSchema = _Object_({
+	verificationMethod: Literal("human-hardware-previewsign"),
+	version: Literal(1),
+	envelope: schemaRef$1(PreviewSignBase64UrlSchema, "PreviewSignBase64Url"),
+	digest: schemaRef$1(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url"),
+	additionalArguments: schemaRef$1(PreviewSignBase64UrlSchema, "PreviewSignBase64Url"),
+	outerCredentialId: schemaRef$1(PreviewSignBase64UrlSchema, "PreviewSignBase64Url"),
+	outerPublicKey: schemaRef$1(PreviewSignEs256PublicKeySchema, "PreviewSignEs256PublicKey"),
+	previewKeyHandle: schemaRef$1(PreviewSignBase64UrlSchema, "PreviewSignBase64Url")
+}, {
+	$id: "PreviewSignChallenge",
+	additionalProperties: false
+});
+var PreviewSignChallengeValueSchema = _Object_({
+	verificationMethod: Literal("human-hardware-previewsign"),
+	value: schemaRef$1(PreviewSignChallengeSchema, "PreviewSignChallenge")
+}, {
+	$id: "PreviewSignChallengeValue",
+	additionalProperties: false
+});
+var PreviewSignChallengeOperationSchema = Union([Literal("credential-registration"), Literal("signing-request")], { $id: "PreviewSignChallengeOperation" });
+var PreviewSignReceiptSchema = _Object_({
+	version: Literal(1),
+	signature: schemaRef$1(PreviewSignP256DerSignatureBase64UrlSchema, "PreviewSignP256DerSignatureBase64Url")
+}, {
+	$id: "PreviewSignReceipt",
+	additionalProperties: false
+});
+var PreviewSignReceiptValueSchema = _Object_({
+	verificationMethod: Literal("human-hardware-previewsign"),
+	value: schemaRef$1(PreviewSignReceiptSchema, "PreviewSignReceipt")
+}, {
+	$id: "PreviewSignReceiptValue",
+	additionalProperties: false
+});
+var previewSignSchemaContext = {
+	PreviewSignBase64Url: PreviewSignBase64UrlSchema,
+	PreviewSignSha256Base64Url: PreviewSignSha256Base64UrlSchema,
+	PreviewSignP256DerSignatureBase64Url: PreviewSignP256DerSignatureBase64UrlSchema,
+	PreviewSignEs256PublicKey: PreviewSignEs256PublicKeySchema,
+	PreviewSignEcdhEsHkdf256PublicKey: PreviewSignEcdhEsHkdf256PublicKeySchema,
+	PreviewSignEsp256PublicKey: PreviewSignEsp256PublicKeySchema,
+	PreviewSignArkgSeedPublicKey: PreviewSignArkgSeedPublicKeySchema,
+	PreviewSignPublicMaterial: PreviewSignPublicMaterialSchema,
+	PreviewSignChallenge: PreviewSignChallengeSchema,
+	PreviewSignChallengeValue: PreviewSignChallengeValueSchema,
+	PreviewSignChallengeOperation: PreviewSignChallengeOperationSchema,
+	PreviewSignReceipt: PreviewSignReceiptSchema,
+	PreviewSignReceiptValue: PreviewSignReceiptValueSchema
+};
+//#endregion
+//#region ../../libs/models/src/verification-method.ts
+/**
+* Persisted and wire-level signing verification method identifiers.
+*
+* This vocabulary is append-only. Never rename, remove, or change an existing
+* value: PostgreSQL rows, workflow inputs, and API clients persist these exact
+* strings. Future signing methods must add a new property and value.
+*/
+var VERIFICATION_METHOD = {
+	AgentEd25519: "agent-ed25519",
+	HumanHardwarePreviewSign: "human-hardware-previewsign"
+};
+VERIFICATION_METHOD.AgentEd25519, VERIFICATION_METHOD.HumanHardwarePreviewSign;
+//#endregion
+//#region ../../libs/models/src/schemas.ts
+var UuidSchema = String$1({
+	format: "uuid",
+	description: "UUID v4 identifier"
+});
+var TimestampSchema = String$1({
+	format: "date-time",
+	description: "ISO 8601 timestamp"
+});
+Union([Literal(VERIFICATION_METHOD.AgentEd25519), Literal(VERIFICATION_METHOD.HumanHardwarePreviewSign)], { description: "Stable signing verification method identifier" });
+Union([
+	Literal("private"),
+	Literal("moltnet"),
+	Literal("public")
+], { description: "Entry visibility level" });
+var ENTRY_TYPE_VALUES = [
+	"episodic",
+	"semantic",
+	"procedural",
+	"reflection"
+];
+var EntryTypeSchema = Union([
+	Literal("episodic"),
+	Literal("semantic"),
+	Literal("procedural"),
+	Literal("reflection")
+], { description: "Entry memory type" });
+/** Regex fragment matching a single entry type value. */
+var ENTRY_TYPE_PATTERN = `(${ENTRY_TYPE_VALUES.join("|")})`;
+`${ENTRY_TYPE_PATTERN}${ENTRY_TYPE_PATTERN}`, ENTRY_TYPE_VALUES.length - 1;
+var PublicKeySchema = String$1({
+	pattern: "^ed25519:[A-Za-z0-9+/=]+$",
+	description: "Ed25519 public key with prefix"
+});
+var FingerprintSchema = String$1({
+	pattern: "^[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}$",
+	description: "Key fingerprint (A1B2-C3D4-E5F6-G7H8)"
+});
+_Object_({
+	title: Optional(String$1({ maxLength: 255 })),
+	content: String$1({
+		minLength: 1,
+		maxLength: 1e5
+	}),
+	tags: Optional(_Array_(String$1({ maxLength: 128 }), { maxItems: 20 }))
+});
+_Object_({
+	title: Optional(String$1({ maxLength: 255 })),
+	content: Optional(String$1({
+		minLength: 1,
+		maxLength: 1e5
+	})),
+	tags: Optional(_Array_(String$1({ maxLength: 128 }), { maxItems: 20 }))
+});
+_Object_({
+	query: Optional(String$1({
+		minLength: 1,
+		maxLength: 500
+	})),
+	tags: Optional(_Array_(String$1({ maxLength: 128 }), {
+		minItems: 1,
+		maxItems: 20,
+		description: "Filter: entry must have ALL specified tags"
+	})),
+	limit: Optional(Number$1({
+		minimum: 1,
+		maximum: 100,
+		default: 20
+	})),
+	offset: Optional(Number$1({
+		minimum: 0,
+		default: 0
+	}))
+});
+_Object_({
+	identityId: UuidSchema,
+	publicKey: PublicKeySchema,
+	fingerprint: FingerprintSchema,
+	createdAt: TimestampSchema
+});
+_Object_({
+	publicKey: PublicKeySchema,
+	fingerprint: FingerprintSchema
+});
+_Object_({ message: String$1({
+	minLength: 1,
+	maxLength: 1e4
+}) });
+_Object_({
+	message: String$1(),
+	signature: String$1({ description: "Base64 encoded Ed25519 signature" }),
+	publicKey: PublicKeySchema
+});
+_Object_({
+	message: String$1({
+		minLength: 1,
+		maxLength: 1e4
+	}),
+	signature: String$1({ description: "Base64 encoded signature" }),
+	publicKey: PublicKeySchema
+});
+_Object_({
+	valid: Boolean$1(),
+	signer: Optional(_Object_({ fingerprint: FingerprintSchema }))
+});
+var BaseAuthContextSchema = _Object_({
+	identityId: UuidSchema,
+	scopes: _Array_(String$1()),
+	subjectType: Union([Literal("agent"), Literal("human")]),
+	currentTeamId: Union([UuidSchema, Null()])
+});
+Union([Intersect([BaseAuthContextSchema, _Object_({
+	subjectType: Literal("agent"),
+	publicKey: PublicKeySchema,
+	fingerprint: FingerprintSchema,
+	clientId: String$1()
+})]), Intersect([BaseAuthContextSchema, _Object_({
+	subjectType: Literal("human"),
+	clientId: Union([String$1(), Null()])
+})])]);
+_Object_({
+	success: Boolean$1(),
+	message: Optional(String$1())
+});
+_Object_({ diaryId: UuidSchema });
+_Object_({
+	diaryId: UuidSchema,
+	entryId: UuidSchema
+});
+_Object_({ entryId: UuidSchema });
+_Object_({ id: UuidSchema });
+_Object_({
+	publicKey: PublicKeySchema,
+	fingerprint: FingerprintSchema,
+	agentName: String$1({
+		minLength: 1,
+		maxLength: 34
+	}),
+	org: Optional(String$1({
+		minLength: 1,
+		maxLength: 39,
+		pattern: "^[a-zA-Z0-9-]+$",
+		description: "GitHub organization name. When provided, the GitHub App will be created under this org instead of the personal account."
+	}))
+});
+_Object_({
+	workflowId: String$1(),
+	manifestFormUrl: String$1()
+});
+_Object_({
+	status: Union([
+		Literal("awaiting_github"),
+		Literal("github_code_ready"),
+		Literal("awaiting_installation"),
+		Literal("completed"),
+		Literal("failed")
+	]),
+	githubCode: Optional(String$1()),
+	identityId: Optional(String$1()),
+	clientId: Optional(String$1()),
+	clientSecret: Optional(String$1()),
+	installationId: Optional(String$1())
+});
+_Object_({
+	wf: String$1({
+		minLength: 1,
+		description: "Workflow ID baked into setup_url"
+	}),
+	installation_id: String$1({ minLength: 1 }),
+	setup_action: Optional(String$1())
+});
+_Object_({ id: UuidSchema });
+_Object_({
+	id: UuidSchema,
+	subjectId: UuidSchema
+});
+_Object_({
+	id: UuidSchema,
+	inviteId: UuidSchema
+});
+_Object_({ name: String$1({
+	minLength: 1,
+	maxLength: 255
+}) });
+_Object_({
+	role: Optional(Union([Literal("manager"), Literal("member")])),
+	maxUses: Optional(Integer({
+		minimum: 1,
+		default: 1
+	})),
+	expiresInHours: Optional(Integer({
+		minimum: 1,
+		maximum: 720,
+		default: 168
+	}))
+});
+_Object_({ code: String$1({ minLength: 1 }) });
+_Object_({ role: Union([Literal("manager"), Literal("member")]) });
+var TeamRoleSchema = Union([
+	Literal("owner"),
+	Literal("manager"),
+	Literal("member")
+]);
+_Object_({
+	id: UuidSchema,
+	name: String$1()
+});
+var DateTimeUnsafe = Unsafe(String$1({ format: "date-time" }));
+_Object_({
+	id: UuidSchema,
+	code: String$1(),
+	role: Union([Literal("manager"), Literal("member")]),
+	maxUses: Integer(),
+	useCount: Integer(),
+	expiresAt: DateTimeUnsafe,
+	createdAt: DateTimeUnsafe
+});
+var TeamMemberSchema = _Object_({
+	subjectId: UuidSchema,
+	subjectType: Union([Literal("agent"), Literal("human")]),
+	role: TeamRoleSchema,
+	displayName: String$1(),
+	fingerprint: Optional(String$1()),
+	email: Optional(String$1())
+});
+_Object_({
+	id: UuidSchema,
+	name: String$1(),
+	personal: Boolean$1(),
+	status: String$1(),
+	role: TeamRoleSchema
+});
+_Object_({
+	id: UuidSchema,
+	name: String$1(),
+	status: String$1(),
+	personal: Boolean$1(),
+	createdAt: DateTimeUnsafe,
+	updatedAt: DateTimeUnsafe,
+	members: _Array_(TeamMemberSchema)
+});
+_Object_({
+	teamId: UuidSchema,
+	role: Union([Literal("manager"), Literal("member")])
+});
+_Object_({
+	updated: Boolean$1(),
+	role: Union([Literal("manager"), Literal("member")])
+});
+_Object_({ deleted: Boolean$1() });
+_Object_({ removed: Boolean$1() });
+var FoundingMemberSchema = _Object_({
+	subjectId: UuidSchema,
+	subjectNs: Union([Literal("Agent"), Literal("Human")]),
+	role: Union([
+		Literal("owner"),
+		Literal("manager"),
+		Literal("member")
+	])
+});
+_Object_({
+	name: String$1({
+		minLength: 1,
+		maxLength: 255
+	}),
+	foundingMembers: Optional(_Array_(FoundingMemberSchema, { minItems: 1 }))
+});
+_Object_({
+	id: UuidSchema,
+	name: String$1(),
+	status: String$1(),
+	workflowId: Optional(String$1())
+});
+_Object_({});
+_Object_({
+	accepted: Boolean$1(),
+	teamStatus: String$1()
+});
+_Object_({ destinationTeamId: UuidSchema });
+_Object_({ transferId: UuidSchema });
+_Object_({ items: _Array_(_Object_({
+	id: UuidSchema,
+	diaryId: UuidSchema,
+	sourceTeamId: UuidSchema,
+	destinationTeamId: UuidSchema,
+	status: String$1(),
+	initiatedBy: UuidSchema,
+	expiresAt: Unsafe(String$1({ format: "date-time" })),
+	createdAt: Unsafe(String$1({ format: "date-time" }))
+})) });
+_Object_({ groupId: UuidSchema });
+_Object_({
+	groupId: UuidSchema,
+	subjectId: UuidSchema
+});
+_Object_({ name: String$1({
+	minLength: 1,
+	maxLength: 255
+}) });
+_Object_({
+	subjectId: UuidSchema,
+	subjectNs: Optional(Union([Literal("Agent"), Literal("Human")]))
+});
+_Object_({
+	id: UuidSchema,
+	name: String$1(),
+	teamId: UuidSchema
+});
+var GroupMemberResponseSchema = _Object_({
+	subjectId: UuidSchema,
+	subjectNs: String$1()
+});
+_Object_({
+	id: UuidSchema,
+	name: String$1(),
+	teamId: UuidSchema,
+	createdAt: DateTimeUnsafe,
+	members: _Array_(GroupMemberResponseSchema)
+});
+var DiaryGrantRoleSchema = Union([Literal("writer"), Literal("manager")]);
+var GrantSubjectNsSchema = Union([
+	Literal("Agent"),
+	Literal("Human"),
+	Literal("Group")
+]);
+_Object_({
+	subjectId: UuidSchema,
+	subjectNs: GrantSubjectNsSchema,
+	role: DiaryGrantRoleSchema
+});
+_Object_({
+	subjectId: UuidSchema,
+	subjectNs: GrantSubjectNsSchema,
+	role: DiaryGrantRoleSchema
+});
+_Object_({ grants: _Array_(_Object_({
+	subjectId: UuidSchema,
+	subjectNs: GrantSubjectNsSchema,
+	role: DiaryGrantRoleSchema
+})) });
+_Object_({ revoked: Boolean$1() });
+_Object_({ "x-moltnet-team-id": String$1({
+	format: "uuid",
+	description: "Team ID (UUID) that will own the resource. Required."
+}) });
+_Object_({ "x-moltnet-team-id": Optional(String$1({
+	format: "uuid",
+	description: "Team ID (UUID) for scoping the request. Optional."
+})) });
+_Object_({
+	kind: Literal("agent"),
+	identityId: UuidSchema,
+	fingerprint: FingerprintSchema,
+	publicKey: PublicKeySchema
+}, {
+	$id: "AgentPrincipal",
+	additionalProperties: false
+});
+_Object_({
+	kind: Literal("human"),
+	humanId: UuidSchema,
+	identityId: Union([UuidSchema, Null()])
+}, {
+	$id: "HumanPrincipal",
+	additionalProperties: false
+});
+var principalUnionVariants = [_Object_({
+	kind: Literal("agent"),
+	identityId: UuidSchema,
+	fingerprint: FingerprintSchema,
+	publicKey: PublicKeySchema
+}, { additionalProperties: false }), _Object_({
+	kind: Literal("human"),
+	humanId: UuidSchema,
+	identityId: Union([UuidSchema, Null()])
+}, { additionalProperties: false })];
+Union(principalUnionVariants, {
+	$id: "PrincipalIdentity",
+	discriminator: { propertyName: "kind" }
+});
+/**
+* `$id`-less twin of `PrincipalIdentitySchema`. Required anywhere the
+* schema is **embedded** inline into another schema (MCP `outputSchema`
+* — every tool that returns a creator-bearing object embeds its own
+* copy; provenance-graph node `meta.creator`, etc.). Ajv 8 throws
+* `reference "PrincipalIdentity" resolves to more than one schema` if
+* the same `$id` appears twice in the same compilation pass, which is
+* exactly what happens when the MCP server lists tools and Ajv
+* traverses every advertised `outputSchema`.
+*
+* Structurally identical to `PrincipalIdentitySchema` (they share the
+* variants array); change one, change both.
+*/
+var PrincipalIdentitySchemaInline = Union(principalUnionVariants, { discriminator: { propertyName: "kind" } });
+//#endregion
+//#region ../../libs/models/src/problem-details.ts
+var ProblemCodeSchema = Union([
+	Literal("UNAUTHORIZED"),
+	Literal("FORBIDDEN"),
+	Literal("NOT_FOUND"),
+	Literal("CONFLICT"),
+	Literal("UNSUPPORTED_MEDIA_TYPE"),
+	Literal("VALIDATION_FAILED"),
+	Literal("INVALID_CHALLENGE"),
+	Literal("INVALID_SIGNATURE"),
+	Literal("VOUCHER_LIMIT"),
+	Literal("RATE_LIMIT_EXCEEDED"),
+	Literal("SERIALIZATION_EXHAUSTED"),
+	Literal("SIGNING_REQUEST_EXPIRED"),
+	Literal("SIGNING_REQUEST_ALREADY_COMPLETED"),
+	Literal("SIGNING_REQUEST_LIMIT_REACHED"),
+	Literal("REGISTRATION_FAILED"),
+	Literal("UPSTREAM_ERROR"),
+	Literal("SERVICE_UNAVAILABLE"),
+	Literal("INTERNAL_SERVER_ERROR"),
+	Literal("TEAM_PERSONAL_IMMUTABLE"),
+	Literal("TEAM_NOT_ACTIVE"),
+	Literal("INVITE_EXPIRED"),
+	Literal("INVITE_EXHAUSTED"),
+	Literal("TEAM_LAST_OWNER"),
+	Literal("TEAM_ALREADY_ACTIVE"),
+	Literal("TEAM_NOT_FOUNDING"),
+	Literal("FOUNDING_ALREADY_ACCEPTED"),
+	Literal("DIARY_TRANSFER_PENDING"),
+	Literal("DIARY_TRANSFER_NOT_FOUND"),
+	Literal("DIARY_TRANSFER_ALREADY_RESOLVED")
+]);
+var ProblemDetailsSchema = _Object_({
+	type: String$1({ format: "uri" }),
+	title: String$1(),
+	status: Integer({
+		minimum: 100,
+		maximum: 599
+	}),
+	code: ProblemCodeSchema,
+	detail: Optional(String$1()),
+	instance: Optional(String$1())
+}, {
+	$id: "ProblemDetails",
+	additionalProperties: true
+});
+_Object_({
+	field: String$1(),
+	message: String$1(),
+	code: Optional(String$1())
+}, {
+	$id: "ValidationError",
+	additionalProperties: false
+});
+_Object_({
+	resource: String$1(),
+	id: Optional(String$1({ format: "uuid" })),
+	keys: Optional(Record(String$1(), String$1()))
+}, {
+	$id: "ConflictTarget",
+	additionalProperties: false
+});
+_Object_({
+	constraint: Optional(String$1()),
+	target: Optional(Ref$1("ConflictTarget"))
+}, {
+	$id: "ConflictError",
+	additionalProperties: false
+});
+var ConflictProblemDetailsSchema = Intersect([ProblemDetailsSchema, _Object_({ conflict: Ref$1("ConflictError") })], { $id: "ConflictProblemDetails" });
+_Object_({
+	type: String$1(),
+	severity: Number$1(),
+	match: String$1()
+}, {
+	$id: "InjectionThreat",
+	additionalProperties: false
+});
+Intersect([ConflictProblemDetailsSchema, _Object_({ flagged: Optional(_Array_(_Object_({
+	id: String$1({ format: "uuid" }),
+	threats: _Array_(Ref$1("InjectionThreat"))
+}, { additionalProperties: false }))) })], { $id: "InjectionConflictProblemDetails" });
+Intersect([ProblemDetailsSchema, _Object_({ errors: _Array_(Ref$1("ValidationError")) })], { $id: "ValidationProblemDetails" });
+Union([
+	Literal("pack"),
+	Literal("entry"),
+	Literal("rendered_pack")
+]);
+var ProvenanceGraphEdgeKindSchema = Union([
+	Literal("includes"),
+	Literal("supersedes"),
+	Literal("rendered_from")
+]);
+var ProvenanceGraphPackMetaSchema = _Object_({
+	packId: UuidSchema,
+	diaryId: UuidSchema,
+	packCid: String$1(),
+	packType: String$1(),
+	packCodec: String$1(),
+	pinned: Boolean$1(),
+	createdAt: TimestampSchema,
+	expiresAt: Union([TimestampSchema, Null()]),
+	supersedesPackId: Union([UuidSchema, Null()])
+});
+/**
+* Discriminated creator embedded inside provenance-node response
+* payloads. Re-uses the shared `PrincipalIdentitySchemaInline` (the
+* `$id`-less twin) — embedding the named `PrincipalIdentitySchema`
+* here would clash with the top-level registration via @fastify/swagger
+* (`reference "PrincipalIdentity" resolves to more than one schema`).
+*/
+var ProvenanceGraphCreatorSchema = PrincipalIdentitySchemaInline;
+var ProvenanceGraphEntryMetaSchema = _Object_({
+	entryId: UuidSchema,
+	diaryId: UuidSchema,
+	entryType: EntryTypeSchema,
+	contentHash: Union([String$1(), Null()]),
+	createdAt: TimestampSchema,
+	updatedAt: TimestampSchema,
+	signed: Boolean$1(),
+	title: Union([String$1(), Null()]),
+	tags: _Array_(String$1()),
+	creator: Optional(ProvenanceGraphCreatorSchema)
+});
+var ProvenanceGraphPackNodeSchema = _Object_({
+	id: String$1(),
+	kind: Literal("pack"),
+	label: String$1(),
+	cid: Union([String$1(), Null()]),
+	meta: Intersect([ProvenanceGraphPackMetaSchema, _Object_({ creator: Optional(ProvenanceGraphCreatorSchema) })])
+});
+var ProvenanceGraphEntryNodeSchema = _Object_({
+	id: String$1(),
+	kind: Literal("entry"),
+	label: String$1(),
+	cid: Union([String$1(), Null()]),
+	meta: ProvenanceGraphEntryMetaSchema
+});
+var ProvenanceGraphRenderedPackMetaSchema = _Object_({
+	renderedPackId: UuidSchema,
+	sourcePackId: UuidSchema,
+	diaryId: UuidSchema,
+	packCid: String$1(),
+	renderMethod: String$1(),
+	totalTokens: Number$1(),
+	pinned: Boolean$1(),
+	createdAt: TimestampSchema,
+	expiresAt: Union([TimestampSchema, Null()]),
+	creator: Optional(ProvenanceGraphCreatorSchema)
+});
+var ProvenanceGraphNodeSchema = Union([
+	ProvenanceGraphPackNodeSchema,
+	ProvenanceGraphEntryNodeSchema,
+	_Object_({
+		id: String$1(),
+		kind: Literal("rendered_pack"),
+		label: String$1(),
+		cid: Union([String$1(), Null()]),
+		meta: ProvenanceGraphRenderedPackMetaSchema
+	})
+]);
+var ProvenanceGraphEdgeSchema = _Object_({
+	id: String$1(),
+	from: String$1(),
+	to: String$1(),
+	kind: ProvenanceGraphEdgeKindSchema,
+	label: Optional(String$1()),
+	meta: Optional(Record(String$1(), Union([
+		String$1(),
+		Number$1(),
+		Boolean$1(),
+		Null()
+	])))
+});
+_Object_({
+	metadata: _Object_({
+		format: Literal("moltnet.provenance-graph/v1"),
+		generatedAt: TimestampSchema,
+		rootNodeId: String$1(),
+		rootPackId: UuidSchema,
+		depth: Number$1({ minimum: 0 })
+	}),
+	nodes: _Array_(ProvenanceGraphNodeSchema),
+	edges: _Array_(ProvenanceGraphEdgeSchema)
+}, { $id: "ProvenanceGraph" });
+//#endregion
+//#region ../../libs/models/src/signer-constraint.ts
+var SIGNER_CONSTRAINT_TYPE = {
+	Human: "human",
+	TeamRole: "team-role",
+	Group: "group"
+};
+Union([
+	_Object_({
+		type: Literal(SIGNER_CONSTRAINT_TYPE.Human),
+		id: String$1({ format: "uuid" })
+	}),
+	_Object_({
+		type: Literal(SIGNER_CONSTRAINT_TYPE.TeamRole),
+		id: TeamRoleSchema
+	}),
+	_Object_({
+		type: Literal(SIGNER_CONSTRAINT_TYPE.Group),
+		id: String$1({ format: "uuid" })
+	})
+]);
+//#endregion
+//#region ../../libs/models/src/signer-protocol.ts
+function schemaRef(schema) {
+	return Ref$1(schemaId(schema));
+}
+function schemaId(schema) {
+	const id = schema.$id;
+	if (typeof id !== "string" || id.length === 0) throw new Error("Signer protocol schemas must have an identifier");
+	return id;
+}
+var SignerBase64UrlSchema = PreviewSignBase64UrlSchema;
+var SignerUuidSchema = String$1({
+	$id: "SignerUuid",
+	pattern: "^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
+});
+var SignerOperationSchema = Union([
+	Literal("credential-enrollment"),
+	Literal("credential-registration"),
+	Literal("signing-request")
+], { $id: "SignerOperation" });
+var SignerChallengeOperationSchema = PreviewSignChallengeOperationSchema;
+var SignerPreviewSignPublicMaterialSchema = PreviewSignPublicMaterialSchema;
+var SignerPreviewSignChallengeValueSchema = PreviewSignChallengeValueSchema;
+var SignerProblemSchema = _Object_({
+	code: String$1({ minLength: 1 }),
+	message: String$1({ minLength: 1 })
+}, {
+	$id: "SignerProblem",
+	additionalProperties: false
+});
+var SignerCeremonyParamsSchema = _Object_({ ceremonyId: Unsafe(schemaRef(SignerBase64UrlSchema)) }, {
+	$id: "SignerCeremonyParams",
+	additionalProperties: false
+});
+var SignerSessionSchema = _Object_({
+	version: Literal(1),
+	token: Unsafe(schemaRef(SignerBase64UrlSchema)),
+	expiresAt: String$1()
+}, {
+	$id: "SignerSession",
+	additionalProperties: false
+});
+var SignerEnrollmentCeremonyRequestSchema = _Object_({
+	version: Literal(1),
+	operation: Literal("credential-enrollment"),
+	label: String$1({
+		minLength: 1,
+		maxLength: 255
+	}),
+	teamId: Unsafe(schemaRef(SignerUuidSchema))
+}, {
+	$id: "SignerEnrollmentCeremonyRequest",
+	additionalProperties: false
+});
+var SignerChallengeCeremonyRequestSchema = _Object_({
+	version: Literal(1),
+	operation: Unsafe(schemaRef(SignerChallengeOperationSchema)),
+	resourceId: Unsafe(schemaRef(SignerUuidSchema)),
+	challenge: Unsafe(schemaRef(SignerPreviewSignChallengeValueSchema))
+}, {
+	$id: "SignerChallengeCeremonyRequest",
+	additionalProperties: false
+});
+var SignerCeremonyRequestSchema = Union([Unsafe(schemaRef(SignerEnrollmentCeremonyRequestSchema)), Unsafe(schemaRef(SignerChallengeCeremonyRequestSchema))], { $id: "SignerCeremonyRequest" });
+var SignerCeremonySchema = _Object_({
+	version: Literal(1),
+	id: Unsafe(schemaRef(SignerBase64UrlSchema)),
+	operation: Unsafe(schemaRef(SignerOperationSchema)),
+	approvalUrl: String$1(),
+	expiresAt: String$1()
+}, {
+	$id: "SignerCeremony",
+	additionalProperties: false
+});
+var SignerPendingResultSchema = _Object_({
+	version: Literal(1),
+	status: Literal("pending"),
+	operation: Unsafe(schemaRef(SignerOperationSchema))
+}, {
+	$id: "SignerPendingResult",
+	additionalProperties: false
+});
+var SignerEnrollmentResultSchema = _Object_({
+	version: Literal(1),
+	status: Literal("completed"),
+	operation: Literal("credential-enrollment"),
+	publicMaterial: Unsafe(schemaRef(SignerPreviewSignPublicMaterialSchema))
+}, {
+	$id: "SignerEnrollmentResult",
+	additionalProperties: false
+});
+var SignerReceiptSchema = PreviewSignReceiptValueSchema;
+var SignerSignatureResultSchema = _Object_({
+	version: Literal(1),
+	status: Literal("completed"),
+	operation: Unsafe(schemaRef(SignerChallengeOperationSchema)),
+	receipt: Unsafe(schemaRef(SignerReceiptSchema))
+}, {
+	$id: "SignerSignatureResult",
+	additionalProperties: false
+});
+var SignerFailedResultSchema = _Object_({
+	version: Literal(1),
+	status: Literal("failed"),
+	operation: Unsafe(schemaRef(SignerOperationSchema)),
+	code: String$1(),
+	message: String$1()
+}, {
+	$id: "SignerFailedResult",
+	additionalProperties: false
+});
+var SignerCeremonyResultSchema = Union([
+	Unsafe(schemaRef(SignerPendingResultSchema)),
+	Unsafe(schemaRef(SignerEnrollmentResultSchema)),
+	Unsafe(schemaRef(SignerSignatureResultSchema)),
+	Unsafe(schemaRef(SignerFailedResultSchema))
+], { $id: "SignerCeremonyResult" });
+({ ...previewSignSchemaContext }), schemaId(SignerUuidSchema), schemaId(SignerOperationSchema), schemaId(SignerProblemSchema), schemaId(SignerCeremonyParamsSchema), schemaId(SignerSessionSchema), schemaId(SignerEnrollmentCeremonyRequestSchema), schemaId(SignerChallengeCeremonyRequestSchema), schemaId(SignerCeremonyRequestSchema), schemaId(SignerCeremonySchema), schemaId(SignerPendingResultSchema), schemaId(SignerEnrollmentResultSchema), schemaId(SignerSignatureResultSchema), schemaId(SignerFailedResultSchema), schemaId(SignerCeremonyResultSchema);
+//#endregion
+//#region ../../libs/models/src/tool-enforcement.ts
+var TOOL_ENFORCEMENT_VALUES = [
+	"off",
+	"watch",
+	"enforce"
+];
+var ToolEnforcementSchema = Union([
+	Literal(TOOL_ENFORCEMENT_VALUES[0]),
+	Literal(TOOL_ENFORCEMENT_VALUES[1]),
+	Literal(TOOL_ENFORCEMENT_VALUES[2])
+], { description: "Runtime tool-policy enforcement mode: off (inert), watch (audit only), enforce (block disallowed tools, fail-closed)." });
+//#endregion
 //#region ../../libs/tasks/src/runtime-profiles.ts
 var RuntimeProfileName = String$1({
 	minLength: 1,
@@ -4480,11 +5349,7 @@ var RuntimeProfileWorkspaceMode = Union([
 * `off` (inert), `watch` (audit only), `enforce` (block disallowed tools,
 * fail-closed). Read by the daemon via `GET /runtime-profiles/:id/allowed-tools`.
 */
-var RuntimeProfileToolEnforcement = Union([
-	Literal("off"),
-	Literal("watch"),
-	Literal("enforce")
-]);
+var RuntimeProfileToolEnforcement = ToolEnforcementSchema;
 var RuntimeProfileAllowedWorkspaceModes = _Array_(RuntimeProfileWorkspaceMode, {
 	minItems: 1,
 	maxItems: 3,
@@ -6537,7 +7402,7 @@ var BUILT_IN_TASK_TYPES = {
 		outputKind: "artifact",
 		resumable: true,
 		workspaceMode: "shared_mount",
-		workspaceScope: "session",
+		workspaceScope: "attempt",
 		sessionScope: "correlation",
 		acceptsInputWorkspaceOverride: true,
 		requiresReferences: false,
@@ -9880,6 +10745,11 @@ function createGhCliClient() {
 	};
 }
 //#endregion
+//#region src/lib/daemon-slot-identity.ts
+function createRuntimeInstanceId() {
+	return randomUUID();
+}
+//#endregion
 //#region src/lib/session-files.ts
 function resolveLatestPiSessionPath(sessionDir) {
 	try {
@@ -9950,10 +10820,10 @@ function slugifySessionComponent(input) {
 }
 //#endregion
 //#region src/lib/task-execution-plan.ts
-function buildDaemonTaskExecutionPlan(task, stateDirs, identity, warmSessionTtlSec, runtimeProfileWorkspacePolicy = {}) {
+function buildDaemonTaskExecutionPlan(task, stateDirs, identity, warmSessionTtlSec, runtimeProfileWorkspacePolicy = {}, attemptN) {
 	const descriptor = deriveTaskSessionDescriptor(task);
 	const workspaceMode = resolveTaskWorkspaceMode(task, descriptor.policy, runtimeProfileWorkspacePolicy);
-	const slotKey = warmSessionTtlSec > 0 ? descriptor.sessionKey : null;
+	const slotKey = warmSessionTtlSec > 0 && descriptor.sessionKey ? buildRuntimeSlotKey(descriptor.sessionKey, identity.runtimeInstanceId) : null;
 	const workspaceScope = slotKey !== null ? descriptor.policy.workspaceScope : "attempt";
 	const slotId = slotKey ? buildDaemonSlotId(identity, slotKey) : null;
 	const sessionDir = slotId ? `${stateDirs.piSessionsDir}/${encodeURIComponent(slotId)}` : null;
@@ -9961,7 +10831,8 @@ function buildDaemonTaskExecutionPlan(task, stateDirs, identity, warmSessionTtlS
 	const workspaceId = workspaceMode !== "shared_mount" ? resolveTaskWorkspaceId(task, {
 		sessionKey: slotId,
 		workspaceScope,
-		sessionPersistence: sessionDir ? { sessionDir } : null
+		sessionPersistence: sessionDir ? { sessionDir } : null,
+		attemptN
 	}) : null;
 	return {
 		descriptor,
@@ -9985,6 +10856,12 @@ function buildDaemonSlotId(identity, slotKey) {
 		slotKey
 	].join(":");
 }
+function buildRuntimeSlotKey(logicalSessionKey, runtimeInstanceId) {
+	return runtimeInstanceId ? `${logicalSessionKey}:worker:${slugSlotIdentityComponent(runtimeInstanceId)}` : logicalSessionKey;
+}
+function runtimeSlotKeyBelongsToInstance(slotKey, runtimeInstanceId) {
+	return slotKey.endsWith(`:worker:${slugSlotIdentityComponent(runtimeInstanceId)}`);
+}
 function slugSlotIdentityComponent(input) {
 	return slugifyAsciiLower(input.trim(), 64, [
 		".",
@@ -10039,7 +10916,7 @@ function toDaemonWorkspaceMode(mode) {
 }
 function resolveTaskWorkspaceId(task, executionPlan) {
 	if (executionPlan.workspaceScope === "session" && executionPlan.sessionKey !== null) return `session-${encodeURIComponent(executionPlan.sessionKey)}`;
-	return `task-${task.id}`;
+	return executionPlan.attemptN ? `daemon-task-${task.id}-attempt-${executionPlan.attemptN}` : `task-${task.id}`;
 }
 //#endregion
 //#region src/lib/execution-plan-cache.ts
@@ -10058,7 +10935,7 @@ function createExecutionPlanCache(args) {
 			const key = buildClaimedTaskKey(claimedTask);
 			const existing = cache.get(key);
 			if (existing) return existing;
-			const plan = await maybeAttachWarmSlotContext(claimedTask, buildDaemonTaskExecutionPlan(claimedTask.task, args.stateDirs, args.slotIdentity, args.warmSessionTtlSec, args.workspacePolicy), args.stateDirs, args.slotRegistry, runtimeSessionStore, sourceAttemptResolver);
+			const plan = await maybeAttachWarmSlotContext(claimedTask, buildDaemonTaskExecutionPlan(claimedTask.task, args.stateDirs, args.slotIdentity, args.warmSessionTtlSec, args.workspacePolicy, claimedTask.attemptN), args.stateDirs, args.slotRegistry, runtimeSessionStore, sourceAttemptResolver);
 			assertPlanAllowedByWorkspacePolicy(plan, args.workspacePolicy);
 			cache.set(key, plan);
 			return plan;
@@ -10125,14 +11002,13 @@ async function resolveWarmSlot(slotRegistry, runtimeSessionStore, teamId, source
 	return {
 		kind: "found",
 		producerSlot: producerContext,
-		sessionPath: sourceSessionPath,
-		workspacePath: resolveProducerWorkspaceCopySource(producerContext, stateDirs)
+		sessionPath: sourceSessionPath
 	};
 }
 async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slotRegistry, runtimeSessionStore, sourceAttemptResolver) {
 	if (claimedTask.task.taskType === "freeform") {
 		const continueFrom = claimedTask.task.input.continueFrom;
-		if (!continueFrom) return basePlan;
+		if (!continueFrom) return maybeAttachRetrySession(claimedTask, basePlan, stateDirs, slotRegistry, runtimeSessionStore);
 		const resolution = await resolveWarmSlot(slotRegistry, runtimeSessionStore, claimedTask.task.teamId, continueFrom.taskId, continueFrom.attemptN, stateDirs);
 		if (resolution.kind === "missing") throw new ProducerContextResolutionError(`Continuation source task ${continueFrom.taskId} attempt ${continueFrom.attemptN} has no local runtime slot or durable runtime session — claim affinity filter should have prevented this claim`);
 		if (resolution.kind === "no-session-path") throw new ProducerContextResolutionError(`Continuation source attempt ${continueFrom.taskId}/${continueFrom.attemptN} has no persisted Pi session path`);
@@ -10164,7 +11040,7 @@ async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slot
 			return {
 				...basePlan,
 				workspaceMode: "dedicated_worktree",
-				workspaceId: recoveredBranch ? `extend-${continueFrom.taskId}-attempt-${continueFrom.attemptN}` : null,
+				workspaceId: recoveredBranch ? buildAttemptWorkspaceId(claimedTask) : null,
 				worktreeBranch: recoveredBranch,
 				sessionPersistence: {
 					sessionDir,
@@ -10193,7 +11069,7 @@ async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slot
 		return {
 			...basePlan,
 			workspaceMode: "dedicated_worktree",
-			workspaceId: resolution.producerSlot.workspace?.workspaceId ?? null,
+			workspaceId: parentBranch ? buildAttemptWorkspaceId(claimedTask) : null,
 			worktreeBranch: parentBranch,
 			sessionPersistence: {
 				sessionDir,
@@ -10215,7 +11091,7 @@ async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slot
 		worktreeBranch: null,
 		workspaceKind: "scratch",
 		workspaceSeed: {
-			copyFromPath: resolution.workspacePath,
+			copyFromPath: resolveProducerWorkspaceCopySource(resolution.producerSlot, stateDirs),
 			source: "producer"
 		},
 		sessionPersistence: {
@@ -10224,6 +11100,25 @@ async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slot
 		}
 	};
 }
+function buildAttemptWorkspaceId(claimedTask) {
+	return `daemon-task-${claimedTask.task.id}-attempt-${claimedTask.attemptN}`;
+}
+async function maybeAttachRetrySession(claimedTask, basePlan, stateDirs, slotRegistry, runtimeSessionStore) {
+	if (claimedTask.attemptN <= 1 || !basePlan.sessionPersistence?.sessionDir) return basePlan;
+	const resolution = await resolveWarmSlot(slotRegistry, runtimeSessionStore, claimedTask.task.teamId, claimedTask.task.id, claimedTask.attemptN - 1, stateDirs);
+	if (resolution.kind === "missing" || resolution.kind === "no-session-path") return basePlan;
+	const sourceSessionDir = dirname(resolution.sessionPath);
+	const targetSessionDir = basePlan.sessionPersistence.sessionDir;
+	if (sourceSessionDir === targetSessionDir) return basePlan;
+	return {
+		...basePlan,
+		worktreeBranch: basePlan.workspaceMode === "dedicated_worktree" && resolution.kind === "found" ? resolution.producerSlot.workspace?.worktreeBranch ?? basePlan.worktreeBranch : basePlan.worktreeBranch,
+		sessionPersistence: {
+			sessionDir: targetSessionDir,
+			forkFromSessionPath: resolution.sessionPath
+		}
+	};
+}
 function buildForkBranch(parentBranch, childTaskId, childAttemptN) {
 	return `${parentBranch}-fork-${childTaskId.slice(0, 8)}-${childAttemptN}`;
 }
@@ -10267,6 +11162,7 @@ var RETRYABLE_CODES = new Set([
 ]);
 var NON_RETRYABLE_CODES = new Set([
 	"bad_api_key",
+	"executor_threw",
 	"invalid_api_key",
 	"invalid_model",
 	"max_turns_exceeded",
@@ -10309,17 +11205,18 @@ var NON_RETRYABLE_MESSAGE_PATTERNS = [
 	/\bmax (?:turn|bash)/i
 ];
 async function classifyAttemptFailure(input) {
-	if (input.remainingAttempts !== null && input.remainingAttempts !== void 0) {
-		if (input.remainingAttempts <= 0) return {
+	const deterministic = classifyDeterministically(input.error);
+	if (input.remainingAttempts !== null && input.remainingAttempts !== void 0 && input.remainingAttempts <= 0) {
+		const deterministicReason = deterministic === "ambiguous" ? "" : ` Deterministic policy classified the failure as ${deterministic}.`;
+		return {
 			error: withRetryInfo(input.error, {
 				retryable: false,
 				source: "attempts_exhausted",
-				reason: `Attempt budget exhausted at attempt ${input.attemptN}${input.maxAttempts ? ` of ${input.maxAttempts}` : ""}.`
+				reason: `Attempt budget exhausted at attempt ${input.attemptN}${input.maxAttempts ? ` of ${input.maxAttempts}` : ""}.${deterministicReason}`
 			}),
 			source: "attempts_exhausted"
 		};
 	}
-	const deterministic = classifyDeterministically(input.error);
 	if (deterministic !== "ambiguous") {
 		const retryable = deterministic === "retryable";
 		const source = input.error.retryable === retryable ? "explicit" : "deterministic";
@@ -10895,6 +11792,269 @@ function createRuntimeProfileRetryTriage(options) {
 	});
 }
 //#endregion
+//#region src/lib/runtime-resource-reaper.ts
+var RUNTIME_SLOT_PAGE_LIMIT = 200;
+var ATTEMPT_LOOKUP_CONCURRENCY = 8;
+var TERMINAL_ATTEMPT_STATUSES = new Set([
+	"completed",
+	"failed",
+	"cancelled",
+	"aborted",
+	"timed_out"
+]);
+/**
+* Reap daemon-owned local resources whose runtime slot is no longer usable.
+* The destructive path is deliberately conservative: uncertainty about slot
+* ownership, attempt state, listing completeness, or real filesystem
+* containment retains resources rather than risking another daemon's data.
+*/
+async function reapRuntimeSlotResources(deps, input) {
+	const now = input.now ?? Date.now();
+	const [activePage, idlePage] = await Promise.all([listOwnedSlots(deps.runtimeSlotStore, input, "active"), listOwnedSlots(deps.runtimeSlotStore, input, "idle")]);
+	const active = activePage.items;
+	const idle = idlePage.items;
+	const slots = [...active, ...idle];
+	const result = {
+		failed: 0,
+		failures: [],
+		removedSessions: 0,
+		removedWorkspaces: 0,
+		scanned: slots.length,
+		truncated: activePage.truncated || idlePage.truncated,
+		unsafePathDetails: [],
+		unsafePaths: 0
+	};
+	const reaped = new Set(idle.filter((item) => item.slot.expiresAtMs <= now).map((item) => item.slot.id));
+	for (const slotId of await findTerminalActiveSlotIds(deps, active, result)) reaped.add(slotId);
+	const retainedSessionDirs = new Set(slots.filter((item) => !reaped.has(item.slot.id)).flatMap((item) => item.session?.sessionDir ? [resolve(item.session.sessionDir)] : []));
+	const retainedWorkspacePaths = new Set(slots.filter((item) => !reaped.has(item.slot.id)).flatMap((item) => item.workspace?.worktreePath ? [resolve(item.workspace.worktreePath)] : []));
+	const worktrees = input.mainWorktree ? await listRegisteredWorktrees(input.mainWorktree) : {
+		kind: "ready",
+		paths: /* @__PURE__ */ new Set()
+	};
+	for (const item of slots) {
+		if (!reaped.has(item.slot.id)) continue;
+		if (!await slotStillQualifiesForReaping(deps, input, item, now, result)) continue;
+		const sessionDir = item.session?.sessionDir;
+		if (sessionDir && !retainedSessionDirs.has(resolve(sessionDir)) && existsSync(sessionDir)) if (!isRealPathInsideRoot(sessionDir, input.sessionRootDir)) recordUnsafePath(deps, result, item.slot.id, sessionDir, input.sessionRootDir);
+		else try {
+			rmSync(sessionDir, {
+				force: true,
+				recursive: true
+			});
+			result.removedSessions++;
+		} catch (err) {
+			recordFailure(deps, result, item.slot.id, sessionDir, input.sessionRootDir, err);
+		}
+		const workspacePath = item.workspace?.worktreePath;
+		if (!workspacePath || retainedWorkspacePaths.has(resolve(workspacePath))) continue;
+		const workspaceRoot = item.workspace?.kind === "scratch" ? input.scratchRootDir : input.mainWorktree ? resolve(input.mainWorktree, ".worktrees") : null;
+		if (!workspaceRoot) {
+			recordUnsafePath(deps, result, item.slot.id, workspacePath, null);
+			continue;
+		}
+		await removeWorkspace(deps, result, worktrees, input.mainWorktree, item.slot.id, workspacePath, workspaceRoot, item.workspace?.kind === "scratch");
+	}
+	if (!result.truncated) await reapLegacyOrphanWorktrees(deps, input, worktrees, retainedSessionDirs, retainedWorkspacePaths, result);
+	return result;
+}
+async function listOwnedSlots(store, input, state) {
+	const listed = await store.listSlots({
+		agentName: input.agentName,
+		limit: RUNTIME_SLOT_PAGE_LIMIT,
+		runtimeProfileId: input.runtimeProfileId,
+		state,
+		teamId: input.teamId
+	});
+	return {
+		items: listed.filter((item) => runtimeSlotKeyBelongsToInstance(item.slot.slotKey, input.runtimeInstanceId)),
+		truncated: listed.length === RUNTIME_SLOT_PAGE_LIMIT
+	};
+}
+async function findTerminalActiveSlotIds(deps, active, result) {
+	const byTask = /* @__PURE__ */ new Map();
+	for (const item of active) {
+		const taskSlots = byTask.get(item.slot.lastTaskId) ?? [];
+		taskSlots.push(item);
+		byTask.set(item.slot.lastTaskId, taskSlots);
+	}
+	const terminal = /* @__PURE__ */ new Set();
+	await mapWithConcurrency([...byTask.entries()], ATTEMPT_LOOKUP_CONCURRENCY, async ([taskId, taskSlots]) => {
+		let attempts;
+		try {
+			attempts = await deps.taskReader.listAttempts(taskId);
+		} catch (err) {
+			recordFailure(deps, result, null, `task:${taskId}`, null, err);
+			return;
+		}
+		for (const item of taskSlots) {
+			const attempt = attempts.find((candidate) => candidate.attemptN === item.slot.lastAttemptN);
+			if (attempt && TERMINAL_ATTEMPT_STATUSES.has(attempt.status)) terminal.add(item.slot.id);
+		}
+	});
+	return terminal;
+}
+async function slotStillQualifiesForReaping(deps, input, original, now, result) {
+	let page;
+	try {
+		page = await listOwnedSlots(deps.runtimeSlotStore, input, original.slot.state);
+	} catch (err) {
+		recordFailure(deps, result, original.slot.id, `slot:${original.slot.id}`, null, err);
+		return false;
+	}
+	const current = page.items.find((candidate) => candidate.slot.id === original.slot.id);
+	if (!current) return false;
+	if (current.slot.lastTaskId !== original.slot.lastTaskId || current.slot.lastAttemptN !== original.slot.lastAttemptN) return false;
+	return current.slot.state === "active" || current.slot.state === "idle" && current.slot.expiresAtMs <= now;
+}
+async function reapLegacyOrphanWorktrees(deps, input, worktrees, retainedSessionDirs, retainedWorkspacePaths, result) {
+	if (!input.mainWorktree) return;
+	const workspaceRoot = resolve(input.mainWorktree, ".worktrees");
+	if (!existsSync(workspaceRoot)) return;
+	let entries;
+	try {
+		entries = readdirSync(workspaceRoot, { withFileTypes: true });
+	} catch (err) {
+		recordFailure(deps, result, null, workspaceRoot, workspaceRoot, err);
+		return;
+	}
+	for (const entry of entries) {
+		if (!entry.isDirectory() || !entry.name.startsWith("session-agent%3A")) continue;
+		const workspacePath = resolve(workspaceRoot, entry.name);
+		if (retainedWorkspacePaths.has(workspacePath)) continue;
+		const sessionDir = resolve(input.sessionRootDir, entry.name.slice(8));
+		if (retainedSessionDirs.has(sessionDir) || existsSync(sessionDir)) continue;
+		await removeWorkspace(deps, result, worktrees, input.mainWorktree, null, workspacePath, workspaceRoot, false);
+	}
+}
+async function removeWorkspace(deps, result, worktrees, mainWorktree, slotId, workspacePath, workspaceRoot, scratch) {
+	if (!existsSync(workspacePath)) return;
+	if (!isRealPathInsideRoot(workspacePath, workspaceRoot)) {
+		recordUnsafePath(deps, result, slotId, workspacePath, workspaceRoot);
+		return;
+	}
+	if (scratch || !mainWorktree) {
+		try {
+			rmSync(workspacePath, {
+				force: true,
+				recursive: true
+			});
+			result.removedWorkspaces++;
+		} catch (err) {
+			recordFailure(deps, result, slotId, workspacePath, workspaceRoot, err);
+		}
+		return;
+	}
+	if (worktrees.kind === "unavailable") {
+		recordFailure(deps, result, slotId, workspacePath, workspaceRoot, new Error(worktrees.reason));
+		return;
+	}
+	try {
+		const canonical = realpathSync(workspacePath);
+		if (worktrees.paths.has(canonical)) {
+			await execFileText("git", [
+				"-C",
+				mainWorktree,
+				"worktree",
+				"remove",
+				"--force",
+				workspacePath
+			]);
+			worktrees.paths.delete(canonical);
+		} else rmSync(workspacePath, {
+			force: true,
+			recursive: true
+		});
+		result.removedWorkspaces++;
+	} catch (err) {
+		recordFailure(deps, result, slotId, workspacePath, workspaceRoot, err);
+	}
+}
+async function listRegisteredWorktrees(mainWorktree) {
+	try {
+		const list = await execFileText("git", [
+			"-C",
+			mainWorktree,
+			"worktree",
+			"list",
+			"--porcelain"
+		]);
+		return {
+			kind: "ready",
+			paths: new Set(list.split("\n").filter((line) => line.startsWith("worktree ")).map((line) => canonicalPath(line.slice(9))))
+		};
+	} catch (err) {
+		return {
+			kind: "unavailable",
+			reason: errorMessage(err)
+		};
+	}
+}
+function isRealPathInsideRoot(path, root) {
+	try {
+		return isResolvedPathInsideRoot$1(realpathSync(path), realpathSync(root));
+	} catch {
+		return false;
+	}
+}
+function isResolvedPathInsideRoot$1(path, root) {
+	const rel = relative(root, path);
+	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function canonicalPath(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return resolve(path);
+	}
+}
+function recordUnsafePath(deps, result, slotId, path, root) {
+	const issue = {
+		kind: "unsafe_path",
+		path,
+		reason: root === null ? "No daemon-owned root was available for this workspace." : "Candidate or root could not be resolved inside the daemon-owned root.",
+		root,
+		slotId
+	};
+	result.unsafePaths++;
+	result.unsafePathDetails.push(issue);
+	emitIssue(deps, issue);
+}
+function recordFailure(deps, result, slotId, path, root, err) {
+	const issue = {
+		kind: "failure",
+		path,
+		reason: errorMessage(err),
+		root,
+		slotId
+	};
+	result.failed++;
+	result.failures.push(issue);
+	emitIssue(deps, issue);
+}
+function emitIssue(deps, issue) {
+	try {
+		deps.onIssue?.(issue);
+	} catch {}
+}
+function errorMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+async function execFileText(file, args) {
+	return new Promise((resolvePromise, reject) => {
+		execFile(file, args, {
+			encoding: "utf8",
+			maxBuffer: 10 * 1024 * 1024
+		}, (err, stdout) => {
+			if (err) reject(err instanceof Error ? err : /* @__PURE__ */ new Error("Child process failed without an Error instance."));
+			else resolvePromise(stdout);
+		});
+	});
+}
+async function mapWithConcurrency(items, concurrency, worker) {
+	for (let index = 0; index < items.length; index += concurrency) await Promise.all(items.slice(index, index + concurrency).map(worker));
+}
+//#endregion
 //#region src/lib/runtime-sessions.ts
 function resolveRuntimeSessionKind(claimedTask) {
 	const continueFrom = resolveContinueFrom(claimedTask);
@@ -11031,6 +12191,8 @@ function createApiRuntimeSlotStore(args) {
 					lastAttemptN: resolved.slot.lastAttemptN,
 					lastTaskId: resolved.slot.lastTaskId,
 					runtimeProfileId: resolved.slot.runtimeProfileId,
+					slotKey: resolved.slot.slotKey,
+					state: resolved.slot.state,
 					taskType: resolved.slot.taskType
 				},
 				session: resolved.slot.sessionDir ? {
@@ -11202,12 +12364,13 @@ async function runPolling(opts) {
 		agent: ctx.agent,
 		profiles: profileValues,
 		teamId,
-		cwd: process.cwd()
+		cwd: ctx.agentRootDir
 	});
 	for (const profile of profiles) validateRuntimeProfilePrerequisites(profile, cfg.profilePrerequisiteEnv, cfg.profilePrerequisitePath);
 	const slotRegistry = createApiRuntimeSlotStore({ agent: ctx.agent });
 	const runtimeSessionStore = createApiRuntimeSessionStore({ agent: ctx.agent });
 	const sourceAttemptResolver = createApiSourceAttemptResolver({ agent: ctx.agent });
+	const runtimeInstanceId = createRuntimeInstanceId();
 	const runtimes = /* @__PURE__ */ new Map();
 	for (const profile of profiles) {
 		const common = parseCommonOptions(values, { runtimeDefaults: {
@@ -11227,7 +12390,8 @@ async function runPolling(opts) {
 		const stateDirs = ensureDaemonStateDirs(sandbox.rootDir);
 		const slotIdentity = {
 			agentName: common.agent,
-			runtimeProfileId: profile.id
+			runtimeProfileId: profile.id,
+			runtimeInstanceId
 		};
 		const executionPlans = createExecutionPlanCache({
 			stateDirs,
@@ -11335,6 +12499,47 @@ async function runPolling(opts) {
 		piAgentDir: piAgentDir.path,
 		piAgentDirSource: piAgentDir.source
 	}, "agent-daemon.starting");
+	let reaperRunning = false;
+	const reapRuntimeResources = async () => {
+		if (reaperRunning) return;
+		reaperRunning = true;
+		try {
+			for (const profile of profiles) {
+				const selected = requireRuntime(runtimes, profile.id);
+				const result = await reapRuntimeSlotResources({
+					onIssue: (issue) => {
+						rootLogger.warn({
+							...issue,
+							runtimeProfileId: profile.id
+						}, "agent-daemon.runtime_resource_reap_issue");
+					},
+					runtimeSlotStore: slotRegistry,
+					taskReader: ctx.agent.tasks
+				}, {
+					agentName: selected.common.agent,
+					mainWorktree: resolveMainWorktree$1(selected.sandbox.rootDir),
+					runtimeInstanceId,
+					runtimeProfileId: profile.id,
+					sessionRootDir: selected.stateDirs.piSessionsDir,
+					scratchRootDir: join(selected.stateDirs.rootDir, "task-workspaces"),
+					teamId
+				});
+				if (result.removedSessions > 0 || result.removedWorkspaces > 0 || result.failed > 0 || result.unsafePaths > 0 || result.truncated) rootLogger.info({
+					...result,
+					runtimeProfileId: profile.id
+				}, "agent-daemon.runtime_resources_reaped");
+			}
+		} catch (err) {
+			rootLogger.warn({ err }, "agent-daemon.runtime_resource_reap_failed");
+		} finally {
+			reaperRunning = false;
+		}
+	};
+	await reapRuntimeResources();
+	const reaperTimer = setInterval(() => {
+		reapRuntimeResources();
+	}, 6e4);
+	reaperTimer.unref();
 	const outputs = [];
 	try {
 		runtime = new AgentRuntime({
@@ -11512,7 +12717,7 @@ async function runPolling(opts) {
 					sessionDir: executionPlan.sessionPersistence.sessionDir,
 					sessionPath: resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir),
 					workspaceId: executionPlan.workspaceId,
-					worktreePath: resolveRecordedWorkspacePath$1(stateDirs.rootDir, executionPlan),
+					worktreePath: resolveRecordedWorkspacePath$1(stateDirs.rootDir, sandbox.rootDir, executionPlan),
 					worktreeBranch: executionPlan.worktreeBranch,
 					workspaceKind: executionPlan.workspaceKind,
 					lastTaskId: claimedTask.task.id,
@@ -11568,15 +12773,23 @@ async function runPolling(opts) {
 		rootLogger.info({ processed: drained.length }, "agent-daemon.drained");
 		return drained.some((o) => o.status !== "completed") ? 1 : 0;
 	} finally {
+		clearInterval(reaperTimer);
 		signalHandlers.dispose();
 		await slotRegistry.close();
 		await otelShutdown();
 		await shutdownLogger();
 	}
 }
-function resolveRecordedWorkspacePath$1(stateRootDir, executionPlan) {
+function resolveRecordedWorkspacePath$1(stateRootDir, mountPath, executionPlan) {
 	if (!executionPlan.workspaceId) return null;
-	return executionPlan.workspaceMode === "scratch_mount" ? join(stateRootDir, "task-workspaces", executionPlan.workspaceId) : join(findMainWorktree(), ".worktrees", executionPlan.workspaceId);
+	return executionPlan.workspaceMode === "scratch_mount" ? join(stateRootDir, "task-workspaces", executionPlan.workspaceId) : join(findMainWorktree(mountPath), ".worktrees", executionPlan.workspaceId);
+}
+function resolveMainWorktree$1(mountPath) {
+	try {
+		return findMainWorktree(mountPath);
+	} catch {
+		return null;
+	}
 }
 function runtimeForClaimedTask(runtimes, claimedTask) {
 	if (!claimedTask.profileId) throw new Error(`Claimed task ${claimedTask.task.id} did not include a selected runtime profile`);
@@ -11668,7 +12881,7 @@ async function runOnce(argv) {
 		agent: ctx.agent,
 		profile: values.profile,
 		teamId: values.team,
-		cwd: process.cwd()
+		cwd: ctx.agentRootDir
 	});
 	validateRuntimeProfilePrerequisites(profile, cfg.profilePrerequisiteEnv, cfg.profilePrerequisitePath);
 	opts = parseCommonOptions(values, { runtimeDefaults: {
@@ -11690,9 +12903,11 @@ async function runOnce(argv) {
 	const slotRegistry = createApiRuntimeSlotStore({ agent: ctx.agent });
 	const runtimeSessionStore = createApiRuntimeSessionStore({ agent: ctx.agent });
 	const sourceAttemptResolver = createApiSourceAttemptResolver({ agent: ctx.agent });
+	const runtimeInstanceId = createRuntimeInstanceId();
 	const slotIdentity = {
 		agentName: opts.agent,
-		runtimeProfileId: profile.id
+		runtimeProfileId: profile.id,
+		runtimeInstanceId
 	};
 	const executionPlans = createExecutionPlanCache({
 		stateDirs,
@@ -11754,6 +12969,26 @@ async function runOnce(argv) {
 		piAgentDir: piAgentDir.path,
 		piAgentDirSource: piAgentDir.source
 	}, "agent-daemon.starting");
+	try {
+		const reaped = await reapRuntimeSlotResources({
+			onIssue: (issue) => {
+				rootLogger.warn(issue, "agent-daemon.runtime_resource_reap_issue");
+			},
+			runtimeSlotStore: slotRegistry,
+			taskReader: ctx.agent.tasks
+		}, {
+			agentName: opts.agent,
+			mainWorktree: resolveMainWorktree(sandbox.rootDir),
+			runtimeInstanceId,
+			runtimeProfileId: profile.id,
+			sessionRootDir: stateDirs.piSessionsDir,
+			scratchRootDir: join(stateDirs.rootDir, "task-workspaces"),
+			teamId: profile.teamId
+		});
+		if (reaped.removedSessions > 0 || reaped.removedWorkspaces > 0 || reaped.failed > 0 || reaped.unsafePaths > 0 || reaped.truncated) rootLogger.info(reaped, "agent-daemon.runtime_resources_reaped");
+	} catch (err) {
+		rootLogger.warn({ err }, "agent-daemon.runtime_resource_reap_failed");
+	}
 	let runtime = null;
 	let activeAttemptN = null;
 	const signalHandlers = installShutdownSignalHandlers({
@@ -11843,7 +13078,7 @@ async function runOnce(argv) {
 				sessionDir: executionPlan.sessionPersistence.sessionDir,
 				sessionPath: resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir),
 				workspaceId: executionPlan.workspaceId,
-				worktreePath: resolveRecordedWorkspacePath(stateDirs.rootDir, executionPlan),
+				worktreePath: resolveRecordedWorkspacePath(stateDirs.rootDir, sandbox.rootDir, executionPlan),
 				worktreeBranch: executionPlan.worktreeBranch,
 				workspaceKind: executionPlan.workspaceKind,
 				lastTaskId: claimedTask.task.id,
@@ -11939,9 +13174,16 @@ async function runOnce(argv) {
 		await shutdownLogger();
 	}
 }
-function resolveRecordedWorkspacePath(stateRootDir, executionPlan) {
+function resolveRecordedWorkspacePath(stateRootDir, mountPath, executionPlan) {
 	if (!executionPlan.workspaceId) return null;
-	return executionPlan.workspaceMode === "scratch_mount" ? join(stateRootDir, "task-workspaces", executionPlan.workspaceId) : join(findMainWorktree(), ".worktrees", executionPlan.workspaceId);
+	return executionPlan.workspaceMode === "scratch_mount" ? join(stateRootDir, "task-workspaces", executionPlan.workspaceId) : join(findMainWorktree(mountPath), ".worktrees", executionPlan.workspaceId);
+}
+function resolveMainWorktree(mountPath) {
+	try {
+		return findMainWorktree(mountPath);
+	} catch {
+		return null;
+	}
 }
 //#endregion
 //#region src/cli/poll.ts