@p4code/cli 0.1.44 → 0.1.46

package/dist/bin.mjs

@@ -237,7 +237,7 @@ const make$87 = () => {
 const layer$79 = Layer.sync(NetService, make$87);
 //#endregion
 //#region package.json
-var version = "0.1.44";
+var version = "0.1.46";
 //#endregion
 //#region src/config.ts
 /**
@@ -1606,6 +1606,7 @@ const ORCHESTRATION_WS_METHODS = {
 	dispatchCommand: "orchestration.dispatchCommand",
 	getTurnDiff: "orchestration.getTurnDiff",
 	getFullThreadDiff: "orchestration.getFullThreadDiff",
+	searchThreads: "orchestration.searchThreads",
 	getArchivedShellSnapshot: "orchestration.getArchivedShellSnapshot",
 	subscribeShell: "orchestration.subscribeShell",
 	subscribeThread: "orchestration.subscribeThread"
@@ -2771,6 +2772,23 @@ const OrchestrationGetFullThreadDiffInput = Schema$1.Struct({
 	toTurnCount: NonNegativeInt,
 	ignoreWhitespace: Schema$1.optionalKey(Schema$1.Boolean)
 });
+const OrchestrationGetFullThreadDiffResult = ThreadTurnDiff;
+const OrchestrationThreadSearchSource = Schema$1.Literals(["user", "assistant"]);
+const OrchestrationSearchThreadsInput = Schema$1.Struct({
+	query: TrimmedString.check(Schema$1.isMinLength(2), Schema$1.isMaxLength(200)),
+	limit: Schema$1.optionalKey(Schema$1.Int.check(Schema$1.isBetween({
+		minimum: 1,
+		maximum: 50
+	})))
+});
+const OrchestrationThreadSearchMatch = Schema$1.Struct({
+	threadId: ThreadId,
+	projectId: ProjectId,
+	source: OrchestrationThreadSearchSource,
+	snippet: Schema$1.String.check(Schema$1.isMaxLength(240)),
+	messageCreatedAt: Schema$1.NullOr(IsoDateTime)
+});
+const OrchestrationSearchThreadsResult = Schema$1.Struct({ matches: Schema$1.Array(OrchestrationThreadSearchMatch) });
 const OrchestrationRpcSchemas = {
 	dispatchCommand: {
 		input: ClientOrchestrationCommand,
@@ -2782,7 +2800,11 @@ const OrchestrationRpcSchemas = {
 	},
 	getFullThreadDiff: {
 		input: OrchestrationGetFullThreadDiffInput,
-		output: ThreadTurnDiff
+		output: OrchestrationGetFullThreadDiffResult
+	},
+	searchThreads: {
+		input: OrchestrationSearchThreadsInput,
+		output: OrchestrationSearchThreadsResult
 	},
 	getArchivedShellSnapshot: {
 		input: Schema$1.Struct({}),
@@ -2813,6 +2835,10 @@ var OrchestrationGetFullThreadDiffError = class extends Schema$1.TaggedErrorClas
 	message: TrimmedNonEmptyString,
 	cause: Schema$1.optional(Schema$1.Defect())
 }) {};
+var OrchestrationSearchThreadsError = class extends Schema$1.TaggedErrorClass()("OrchestrationSearchThreadsError", {
+	message: TrimmedNonEmptyString,
+	cause: Schema$1.optional(Schema$1.Defect())
+}) {};
 //#endregion
 //#region ../../packages/contracts/src/vcs.ts
 const VcsDriverKind = Schema$1.Literals([
@@ -8981,6 +9007,67 @@ var TicketResolveError = class extends Schema$1.TaggedErrorClass()("TicketResolv
 	}
 };
 //#endregion
+//#region ../../packages/contracts/src/tracker.ts
+/**
+* Connecting an external issue tracker, by whichever transport is available.
+*
+* A tracker can be reached two ways: through a p4code-held API key, or through
+* the MCP server the user registered for it. The API key wins when both exist,
+* because it is the transport p4code can verify at the moment it is entered;
+* the MCP registration remains as the fallback so a machine that never entered
+* a key keeps working exactly as it did.
+*
+* The schemas are provider-keyed rather than Linear-shaped so the next tracker
+* adds a literal to `TrackerProviderName` instead of a parallel set of calls.
+*
+* @module contracts/tracker
+*/
+/** Every tracker p4code can talk to. Today that is Linear. */
+const TrackerProviderName = Schema$1.Literals(["linear"]);
+/**
+* Which transport a tracker call would use right now.
+*
+* `none` is a real answer rather than an error: the settings panel renders it
+* as "not connected", and the board uses it to disable the tracker source with
+* a reason instead of offering one that fails every call.
+*/
+const TrackerConnectionMode = Schema$1.Literals([
+	"api",
+	"mcp",
+	"none"
+]);
+const TrackerStatus = Schema$1.Struct({
+	provider: TrackerProviderName,
+	mode: TrackerConnectionMode,
+	/**
+	* The workspace the API key belongs to, learned when the key was verified.
+	* Null in `mcp` and `none` modes, where p4code holds no credential to ask
+	* with.
+	*/
+	workspace: Schema$1.NullOr(Schema$1.String)
+});
+const TrackerProviderInput = Schema$1.Struct({ provider: TrackerProviderName });
+const TrackerApiKeyInput = Schema$1.Struct({
+	provider: TrackerProviderName,
+	apiKey: TrimmedNonEmptyString
+});
+/**
+* Why an API key could not be stored or removed.
+*
+* `invalid_key` means the tracker itself rejected the key when it was
+* verified, so nothing was stored; the fix is a different key. `unavailable`
+* means the tracker or the secret store could not be reached, so the same key
+* may well work on retry. The two deserve different sentences in the panel.
+*/
+var TrackerApiKeyError = class extends Schema$1.TaggedErrorClass()("TrackerApiKeyError", {
+	reason: Schema$1.Literals(["invalid_key", "unavailable"]),
+	detail: Schema$1.String
+}) {
+	get message() {
+		return this.detail;
+	}
+};
+//#endregion
 //#region ../../packages/contracts/src/threadControl.ts
 /**
 * Thread control over MCP - the toolkit an agent uses to act on its own thread
@@ -10441,6 +10528,9 @@ const WS_METHODS = {
 	mcpSetSecret: "mcp.setSecret",
 	mcpOAuthBegin: "mcp.oauthBegin",
 	mcpOAuthDisconnect: "mcp.oauthDisconnect",
+	trackerStatus: "tracker.status",
+	trackerSetApiKey: "tracker.setApiKey",
+	trackerClearApiKey: "tracker.clearApiKey",
 	sourceControlLookupRepository: "sourceControl.lookupRepository",
 	sourceControlCloneRepository: "sourceControl.cloneRepository",
 	sourceControlPublishRepository: "sourceControl.publishRepository",
@@ -10746,6 +10836,31 @@ const WsMcpOAuthBeginRpc = Rpc.make(WS_METHODS.mcpOAuthBegin, {
 	success: McpOAuthBeginResult,
 	error: Schema$1.Union([McpRegistryError, EnvironmentAuthorizationError])
 });
+/**
+* The tracker's API-key trio, beside the MCP calls rather than folded into
+* them: the key belongs to a tracker provider, not to an MCP server, and it
+* must be settable on a machine that has no such server registered at all —
+* that is the case the key exists for.
+*
+* `setApiKey` verifies the key against the tracker before storing it, and its
+* success carries the workspace the tracker reported, so the panel can say
+* "connected to omnicasa" rather than "saved".
+*/
+const WsTrackerStatusRpc = Rpc.make(WS_METHODS.trackerStatus, {
+	payload: TrackerProviderInput,
+	success: TrackerStatus,
+	error: Schema$1.Union([EnvironmentAuthorizationError])
+});
+const WsTrackerSetApiKeyRpc = Rpc.make(WS_METHODS.trackerSetApiKey, {
+	payload: TrackerApiKeyInput,
+	success: TrackerStatus,
+	error: Schema$1.Union([TrackerApiKeyError, EnvironmentAuthorizationError])
+});
+const WsTrackerClearApiKeyRpc = Rpc.make(WS_METHODS.trackerClearApiKey, {
+	payload: TrackerProviderInput,
+	success: TrackerStatus,
+	error: Schema$1.Union([TrackerApiKeyError, EnvironmentAuthorizationError])
+});
 const WsMcpOAuthDisconnectRpc = Rpc.make(WS_METHODS.mcpOAuthDisconnect, {
 	payload: McpServerNameInput,
 	success: McpServerList,
@@ -11178,6 +11293,11 @@ const WsOrchestrationGetFullThreadDiffRpc = Rpc.make(ORCHESTRATION_WS_METHODS.ge
 	success: OrchestrationRpcSchemas.getFullThreadDiff.output,
 	error: Schema$1.Union([OrchestrationGetFullThreadDiffError, EnvironmentAuthorizationError])
 });
+const WsOrchestrationSearchThreadsRpc = Rpc.make(ORCHESTRATION_WS_METHODS.searchThreads, {
+	payload: OrchestrationSearchThreadsInput,
+	success: OrchestrationRpcSchemas.searchThreads.output,
+	error: Schema$1.Union([OrchestrationSearchThreadsError, EnvironmentAuthorizationError])
+});
 const WsOrchestrationGetArchivedShellSnapshotRpc = Rpc.make(ORCHESTRATION_WS_METHODS.getArchivedShellSnapshot, {
 	payload: OrchestrationRpcSchemas.getArchivedShellSnapshot.input,
 	success: OrchestrationRpcSchemas.getArchivedShellSnapshot.output,
@@ -11229,7 +11349,7 @@ const WsSubscribeAuthAccessRpc = Rpc.make(WS_METHODS.subscribeAuthAccess, {
 	error: Schema$1.Union([AuthAccessStreamError, EnvironmentAuthorizationError]),
 	stream: true
 });
-const WsRpcGroup = RpcGroup.make(WsServerProbeRpc, WsServerGetConfigRpc, WsServerRefreshProvidersRpc, WsServerUpdateProviderRpc, WsServerUpdateServerRpc, WsServerUpsertKeybindingRpc, WsServerRemoveKeybindingRpc, WsServerGetSettingsRpc, WsServerUpdateSettingsRpc, WsServerDiscoverSourceControlRpc, WsServerGetProviderUsageRpc, WsServerGetUsageSummaryRpc, WsServerGetTraceDiagnosticsRpc, WsServerGetProcessDiagnosticsRpc, WsServerGetProcessResourceHistoryRpc, WsServerSignalProcessRpc, WsPullRequestsListRpc, WsPullRequestsListStatsRpc, WsPullRequestsDetailRpc, WsPullRequestsActivityRpc, WsPullRequestsDiffFileContentsRpc, WsPullRequestsRunActionRpc, WsPullRequestsUpdateRpc, WsPullRequestsCommentRpc, WsPullRequestsUpdateCommentRpc, WsPullRequestsSubmitReviewRpc, WsPullRequestsReplyToThreadRpc, WsPullRequestsSetThreadResolutionRpc, WsPullRequestsSetReactionRpc, WsPullRequestsInvalidateRpc, WsPullRequestsReviewerCandidatesRpc, WsPullRequestsRequestReviewersRpc, WsSourceControlLookupRepositoryRpc, WsSourceControlCloneRepositoryRpc, WsSourceControlPublishRepositoryRpc, WsProjectsListEntriesRpc, WsProjectsReadFileRpc, WsProjectsSearchEntriesRpc, WsProjectsWriteFileRpc, WsShellOpenInEditorRpc, WsFilesystemBrowseRpc, WsAssetsCreateUrlRpc, WsSubscribeVcsStatusRpc, WsVcsPullRpc, WsVcsRefreshStatusRpc, WsGitRunStackedActionRpc, WsGitResolvePullRequestRpc, WsGitPreparePullRequestThreadRpc, WsVcsListRefsRpc, WsVcsCreateWorktreeRpc, WsVcsRemoveWorktreeRpc, WsVcsCreateRefRpc, WsVcsSwitchRefRpc, WsVcsInitRpc, WsReviewGetDiffPreviewRpc, WsTerminalOpenRpc, WsTerminalAttachRpc, WsTerminalWriteRpc, WsTerminalResizeRpc, WsTerminalClearRpc, WsTerminalRestartRpc, WsTerminalCloseRpc, WsSubscribeTerminalEventsRpc, WsSubscribeTerminalMetadataRpc, WsPreviewOpenRpc, WsPreviewNavigateRpc, WsPreviewResizeRpc, WsPreviewRefreshRpc, WsPreviewCloseRpc, WsPreviewListRpc, WsPreviewReportStatusRpc, WsPreviewAutomationConnectRpc, WsPreviewAutomationRespondRpc, WsPreviewAutomationFocusHostRpc, WsSubscribePreviewEventsRpc, WsSubscribeDiscoveredLocalServersRpc, WsSubscribeServerConfigRpc, WsSubscribeServerLifecycleRpc, WsSubscribeAuthAccessRpc, WsTasksListRpc, WsTasksGetRpc, WsTasksCreateRpc, WsTasksUpdateRpc, WsTasksDeleteRpc, WsTasksStartThreadRpc, WsSubscribeTasksRpc, WsHubGetSyncStatusRpc, WsHubConnectRpc, WsHubDisconnectRpc, WsHubSetSyncModeRpc, WsHubSetShareModeRpc, WsHubMintTokenRpc, WsSkillsSyncRpc, WsSkillsPublishRpc, WsSkillsPublishAllRpc, WsSkillsUnpublishRpc, WsAssetsReadRpc, WsAssetsSaveRpc, WsAssetsDeleteRpc, WsAssetsCreateLocalRpc, WsAssetsRemoveLocalRpc, WsSkillRegistrySearchRpc, WsSkillRegistryFetchRpc, WsMcpListRpc, WsMcpSaveRpc, WsMcpRemoveRpc, WsMcpSetSecretRpc, WsMcpOAuthBeginRpc, WsMcpOAuthDisconnectRpc, WsOrchestrationDispatchCommandRpc, WsOrchestrationGetTurnDiffRpc, WsOrchestrationGetFullThreadDiffRpc, WsOrchestrationGetArchivedShellSnapshotRpc, WsOrchestrationSubscribeShellRpc, WsOrchestrationSubscribeThreadRpc);
+const WsRpcGroup = RpcGroup.make(WsServerProbeRpc, WsServerGetConfigRpc, WsServerRefreshProvidersRpc, WsServerUpdateProviderRpc, WsServerUpdateServerRpc, WsServerUpsertKeybindingRpc, WsServerRemoveKeybindingRpc, WsServerGetSettingsRpc, WsServerUpdateSettingsRpc, WsServerDiscoverSourceControlRpc, WsServerGetProviderUsageRpc, WsServerGetUsageSummaryRpc, WsServerGetTraceDiagnosticsRpc, WsServerGetProcessDiagnosticsRpc, WsServerGetProcessResourceHistoryRpc, WsServerSignalProcessRpc, WsPullRequestsListRpc, WsPullRequestsListStatsRpc, WsPullRequestsDetailRpc, WsPullRequestsActivityRpc, WsPullRequestsDiffFileContentsRpc, WsPullRequestsRunActionRpc, WsPullRequestsUpdateRpc, WsPullRequestsCommentRpc, WsPullRequestsUpdateCommentRpc, WsPullRequestsSubmitReviewRpc, WsPullRequestsReplyToThreadRpc, WsPullRequestsSetThreadResolutionRpc, WsPullRequestsSetReactionRpc, WsPullRequestsInvalidateRpc, WsPullRequestsReviewerCandidatesRpc, WsPullRequestsRequestReviewersRpc, WsSourceControlLookupRepositoryRpc, WsSourceControlCloneRepositoryRpc, WsSourceControlPublishRepositoryRpc, WsProjectsListEntriesRpc, WsProjectsReadFileRpc, WsProjectsSearchEntriesRpc, WsProjectsWriteFileRpc, WsShellOpenInEditorRpc, WsFilesystemBrowseRpc, WsAssetsCreateUrlRpc, WsSubscribeVcsStatusRpc, WsVcsPullRpc, WsVcsRefreshStatusRpc, WsGitRunStackedActionRpc, WsGitResolvePullRequestRpc, WsGitPreparePullRequestThreadRpc, WsVcsListRefsRpc, WsVcsCreateWorktreeRpc, WsVcsRemoveWorktreeRpc, WsVcsCreateRefRpc, WsVcsSwitchRefRpc, WsVcsInitRpc, WsReviewGetDiffPreviewRpc, WsTerminalOpenRpc, WsTerminalAttachRpc, WsTerminalWriteRpc, WsTerminalResizeRpc, WsTerminalClearRpc, WsTerminalRestartRpc, WsTerminalCloseRpc, WsSubscribeTerminalEventsRpc, WsSubscribeTerminalMetadataRpc, WsPreviewOpenRpc, WsPreviewNavigateRpc, WsPreviewResizeRpc, WsPreviewRefreshRpc, WsPreviewCloseRpc, WsPreviewListRpc, WsPreviewReportStatusRpc, WsPreviewAutomationConnectRpc, WsPreviewAutomationRespondRpc, WsPreviewAutomationFocusHostRpc, WsSubscribePreviewEventsRpc, WsSubscribeDiscoveredLocalServersRpc, WsSubscribeServerConfigRpc, WsSubscribeServerLifecycleRpc, WsSubscribeAuthAccessRpc, WsTasksListRpc, WsTasksGetRpc, WsTasksCreateRpc, WsTasksUpdateRpc, WsTasksDeleteRpc, WsTasksStartThreadRpc, WsSubscribeTasksRpc, WsHubGetSyncStatusRpc, WsHubConnectRpc, WsHubDisconnectRpc, WsHubSetSyncModeRpc, WsHubSetShareModeRpc, WsHubMintTokenRpc, WsSkillsSyncRpc, WsSkillsPublishRpc, WsSkillsPublishAllRpc, WsSkillsUnpublishRpc, WsAssetsReadRpc, WsAssetsSaveRpc, WsAssetsDeleteRpc, WsAssetsCreateLocalRpc, WsAssetsRemoveLocalRpc, WsSkillRegistrySearchRpc, WsSkillRegistryFetchRpc, WsMcpListRpc, WsMcpSaveRpc, WsMcpRemoveRpc, WsMcpSetSecretRpc, WsMcpOAuthBeginRpc, WsMcpOAuthDisconnectRpc, WsTrackerStatusRpc, WsTrackerSetApiKeyRpc, WsTrackerClearApiKeyRpc, WsOrchestrationDispatchCommandRpc, WsOrchestrationGetTurnDiffRpc, WsOrchestrationGetFullThreadDiffRpc, WsOrchestrationSearchThreadsRpc, WsOrchestrationGetArchivedShellSnapshotRpc, WsOrchestrationSubscribeShellRpc, WsOrchestrationSubscribeThreadRpc);
 //#endregion
 //#region ../../packages/shared/src/oauthScope.ts
 const OAUTH_SCOPE_TOKEN = /^[\u0021\u0023-\u005b\u005d-\u007e]+$/u;
@@ -26505,6 +26625,17 @@ const ProjectionCountsRowSchema = Schema$1.Struct({
 	projectCount: Schema$1.Number,
 	threadCount: Schema$1.Number
 });
+const ProjectionThreadSearchRequest = Schema$1.Struct({
+	pattern: Schema$1.String,
+	limit: Schema$1.Int
+});
+const ProjectionThreadSearchRow = Schema$1.Struct({
+	threadId: ThreadId,
+	projectId: ProjectId,
+	source: OrchestrationThreadSearchSource,
+	matchText: Schema$1.String,
+	messageCreatedAt: Schema$1.NullOr(IsoDateTime)
+});
 const WorkspaceRootLookupInput = Schema$1.Struct({ workspaceRoot: Schema$1.String });
 const ProjectIdLookupInput = Schema$1.Struct({ projectId: ProjectId });
 const ThreadIdLookupInput = Schema$1.Struct({ threadId: ThreadId });
@@ -26541,6 +26672,23 @@ function maxIso(left, right) {
 	if (left === null) return right;
 	return left > right ? left : right;
 }
+function escapeLikePattern(value) {
+	return value.replaceAll("!", "!!").replaceAll("%", "!%").replaceAll("_", "!_");
+}
+function foldAsciiCase(value) {
+	return value.replace(/[A-Z]/g, (character) => character.toLowerCase());
+}
+function buildSearchSnippet(text, query) {
+	const normalizedText = text.replace(/\s+/g, " ").trim();
+	if (normalizedText.length <= 240) return normalizedText;
+	const normalizedQuery = foldAsciiCase(query.replace(/\s+/g, " ").trim());
+	const matchIndex = foldAsciiCase(normalizedText).indexOf(normalizedQuery);
+	const bodyLength = 236;
+	const idealStart = Math.max(0, matchIndex - 72);
+	const start = Math.min(idealStart, normalizedText.length - bodyLength);
+	const end = Math.min(normalizedText.length, start + bodyLength);
+	return `${start > 0 ? "…" : ""}${normalizedText.slice(start, end)}${end < normalizedText.length ? "…" : ""}`;
+}
 function computeSnapshotSequence(stateRows) {
 	if (stateRows.length === 0) return 0;
 	const sequenceByProjector = new Map(stateRows.map((row) => [row.projector, row.lastAppliedSequence]));
@@ -26965,6 +27113,72 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
         SELECT
           (SELECT COUNT(*) FROM projection_projects) AS "projectCount",
           (SELECT COUNT(*) FROM projection_threads) AS "threadCount"
+      `
+	});
+	const searchActiveThreadRows = SqlSchema.findAll({
+		Request: ProjectionThreadSearchRequest,
+		Result: ProjectionThreadSearchRow,
+		execute: ({ pattern, limit }) => sql`
+        WITH ranked AS (
+          SELECT
+            threads.thread_id AS thread_id,
+            threads.project_id AS project_id,
+            CASE messages.role
+              WHEN 'user' THEN 'user'
+              ELSE 'assistant'
+            END AS source,
+            messages.text AS match_text,
+            messages.created_at AS message_created_at,
+            CASE messages.role
+              WHEN 'user' THEN 0
+              ELSE 1
+            END AS match_rank,
+            threads.updated_at AS thread_updated_at,
+            ROW_NUMBER() OVER (
+              PARTITION BY threads.thread_id
+              ORDER BY
+                CASE messages.role
+                  WHEN 'user' THEN 0
+                  ELSE 1
+                END ASC,
+                messages.created_at DESC,
+                messages.message_id ASC
+            ) AS thread_match_rank
+          FROM projection_thread_messages AS messages
+          INNER JOIN projection_threads AS threads
+            ON threads.thread_id = messages.thread_id
+          INNER JOIN projection_projects AS projects
+            ON projects.project_id = threads.project_id
+          WHERE threads.deleted_at IS NULL
+            AND threads.archived_at IS NULL
+            AND projects.deleted_at IS NULL
+            AND messages.is_streaming = 0
+            AND (
+              messages.role = 'user'
+              OR (
+                messages.role = 'assistant'
+                AND messages.message_id IN (
+                  SELECT turns.assistant_message_id
+                  FROM projection_turns AS turns
+                  WHERE turns.assistant_message_id IS NOT NULL
+                )
+              )
+            )
+            AND messages.text LIKE ${pattern} ESCAPE '!'
+        )
+        SELECT
+          thread_id AS "threadId",
+          project_id AS "projectId",
+          source,
+          match_text AS "matchText",
+          message_created_at AS "messageCreatedAt"
+        FROM ranked
+        WHERE thread_match_rank = 1
+        ORDER BY
+          match_rank ASC,
+          thread_updated_at DESC,
+          thread_id ASC
+        LIMIT ${limit}
       `
 	});
 	const getActiveProjectRowByWorkspaceRoot = SqlSchema.findOneOption({
@@ -27664,6 +27878,19 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 			toCheckpointRef: row.value.toCheckpointRef
 		});
 	});
+	const searchThreads = (input) => Effect.gen(function* () {
+		const escapedQuery = escapeLikePattern(input.query);
+		return { matches: (yield* searchActiveThreadRows({
+			pattern: `%${escapedQuery}%`,
+			limit: input.limit ?? 50
+		}).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.searchThreads:query", "ProjectionSnapshotQuery.searchThreads:decodeRows")))).map((row) => ({
+			threadId: row.threadId,
+			projectId: row.projectId,
+			source: row.source,
+			snippet: buildSearchSnippet(row.matchText, input.query),
+			messageCreatedAt: row.messageCreatedAt
+		})) };
+	});
 	const getThreadShellById = (threadId) => Effect.gen(function* () {
 		const [threadRow, latestTurnRow, sessionRow] = yield* Effect.all([
 			getActiveThreadRowById({ threadId }).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadShellById:getThread:query", "ProjectionSnapshotQuery.getThreadShellById:getThread:decodeRow"))),
@@ -27784,6 +28011,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 		getSnapshot,
 		getShellSnapshot,
 		getArchivedShellSnapshot,
+		searchThreads,
 		getSnapshotSequence,
 		getCounts,
 		getActiveProjectByWorkspaceRoot,
@@ -34223,7 +34451,7 @@ const NESTED_PAYLOAD_KEYS = [
 	"operations"
 ];
 const MAX_COLLECT_DEPTH = 4;
-function asRecord$6(value) {
+function asRecord$7(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
 }
 function pushChangedFilePath(target, value) {
@@ -34238,7 +34466,7 @@ function collectChangedFilePaths(value, target, depth) {
 		for (const entry of value) collectChangedFilePaths(entry, target, depth + 1);
 		return;
 	}
-	const record = asRecord$6(value);
+	const record = asRecord$7(value);
 	if (!record) return;
 	for (const field of CHANGED_FILE_FIELDS) pushChangedFilePath(target, record[field]);
 	for (const nestedKey of NESTED_PAYLOAD_KEYS) if (nestedKey in record) collectChangedFilePaths(record[nestedKey], target, depth + 1);
@@ -34249,7 +34477,7 @@ function collectChangedFilePaths(value, target, depth) {
 */
 function collectActivityChangedFilePaths(payload) {
 	const target = /* @__PURE__ */ new Set();
-	collectChangedFilePaths(asRecord$6(asRecord$6(payload)?.data), target, 0);
+	collectChangedFilePaths(asRecord$7(asRecord$7(payload)?.data), target, 0);
 	return target;
 }
 /**
@@ -37352,22 +37580,22 @@ function classifyToolCategory(input) {
 	if (normalized.includes("image")) return "image_view";
 	return "tool";
 }
-function asRecord$5(value) {
+function asRecord$6(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 /** Classify from a runtime item payload's `data` (`{ toolName, input }`). */
 function classifyToolCategoryFromToolData(data) {
-	const record = asRecord$5(data);
+	const record = asRecord$6(data);
 	const toolName = record?.toolName;
 	if (typeof toolName !== "string" || toolName.trim().length === 0) return;
 	return classifyToolCategory({
 		toolName,
-		toolInput: asRecord$5(record?.input)
+		toolInput: asRecord$6(record?.input)
 	});
 }
 //#endregion
 //#region src/orchestration/ActivityPayloadProjection.ts
-function asRecord$4(value) {
+function asRecord$5(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function asTrimmedString$1(value) {
@@ -37390,7 +37618,7 @@ function collectChangedFiles(value, target, seen, depth) {
 		}
 		return;
 	}
-	const record = asRecord$4(value);
+	const record = asRecord$5(value);
 	if (!record) return;
 	pushChangedFile(target, seen, record.path);
 	pushChangedFile(target, seen, record.filePath);
@@ -37416,13 +37644,13 @@ function collectChangedFiles(value, target, seen, depth) {
 	}
 }
 function projectCommandData(data) {
-	const item = asRecord$4(data.item);
+	const item = asRecord$5(data.item);
 	if (!item) return;
 	const projectedItem = {};
 	if ("command" in item) projectedItem.command = item.command;
-	const input = asRecord$4(item.input);
+	const input = asRecord$5(item.input);
 	if (input && "command" in input) projectedItem.input = { command: input.command };
-	const result = asRecord$4(item.result);
+	const result = asRecord$5(item.result);
 	if (result && "command" in result) projectedItem.result = { command: result.command };
 	return Object.keys(projectedItem).length > 0 ? projectedItem : void 0;
 }
@@ -37438,7 +37666,7 @@ function summarizeToolTextOutput(value) {
 	return null;
 }
 function projectRawOutput(value) {
-	const rawOutput = asRecord$4(value);
+	const rawOutput = asRecord$5(value);
 	if (!rawOutput) return;
 	if (typeof rawOutput.totalFiles === "number" && Number.isFinite(rawOutput.totalFiles)) return {
 		totalFiles: rawOutput.totalFiles,
@@ -37460,14 +37688,14 @@ function projectRawOutput(value) {
 * the full payload in persistence and the event store.
 */
 function projectActivityPayload(activity) {
-	const payload = asRecord$4(activity.payload);
-	const data = asRecord$4(payload?.data);
+	const payload = asRecord$5(activity.payload);
+	const data = asRecord$5(payload?.data);
 	if (!payload || !data || payload.itemType === "mcp_tool_call") return activity;
 	const projectedData = {};
 	const item = projectCommandData(data);
 	if (item) projectedData.item = item;
 	if ("command" in data) projectedData.command = data.command;
-	const input = asRecord$4(data.input);
+	const input = asRecord$5(data.input);
 	if (input && "command" in input) projectedData.input = { command: input.command };
 	const changedFiles = [];
 	collectChangedFiles(data, changedFiles, /* @__PURE__ */ new Set(), 0);
@@ -37494,7 +37722,7 @@ function projectActivityPayload(activity) {
 */
 function isResolvableContextWindowActivity(activity) {
 	if (activity.kind !== "context-window.updated") return false;
-	const usedTokens = asRecord$4(activity.payload)?.usedTokens;
+	const usedTokens = asRecord$5(activity.payload)?.usedTokens;
 	return typeof usedTokens === "number" && Number.isFinite(usedTokens) && usedTokens >= 0;
 }
 /**
@@ -37510,7 +37738,7 @@ function isResolvableContextWindowActivity(activity) {
 * client.
 */
 function withoutContextWindowBreakdown$1(activity) {
-	const payload = asRecord$4(activity.payload);
+	const payload = asRecord$5(activity.payload);
 	if (!payload || payload.breakdown === void 0) return activity;
 	const { breakdown: _breakdown, ...rest } = payload;
 	return {
@@ -37525,7 +37753,7 @@ function dropStaleContextWindowActivities(activities) {
 	const retainedIndexes = new Set(latestIndexByTurn.values());
 	let breakdownIndex = null;
 	for (const index of retainedIndexes) {
-		if (asRecord$4(activities[index].payload)?.breakdown === void 0) continue;
+		if (asRecord$5(activities[index].payload)?.breakdown === void 0) continue;
 		if (breakdownIndex === null || index > breakdownIndex) breakdownIndex = index;
 	}
 	return activities.flatMap((activity, index) => {
@@ -37654,7 +37882,7 @@ const normalizeDispatchCommand = (command) => Effect.gen(function* () {
 * already negotiated.
 */
 const MCP_PROTOCOL_VERSION = "2025-06-18";
-const REQUEST_TIMEOUT_MS$1 = 15e3;
+const REQUEST_TIMEOUT_MS$2 = 15e3;
 var McpToolCallError = class extends Schema$1.TaggedErrorClass()("McpToolCallError", {
 	detail: Schema$1.String,
 	status: Schema$1.NullOr(Schema$1.Number)
@@ -37718,7 +37946,7 @@ const callMcpTool = Effect.fn("McpToolClient.callMcpTool")(function* (input) {
 		...input.headers,
 		...extraHeaders,
 		accept: "application/json, text/event-stream"
-	}), body)).pipe(Effect.timeout(REQUEST_TIMEOUT_MS$1), Effect.catchCause((cause) => Effect.fail(new McpToolCallError({
+	}), body)).pipe(Effect.timeout(REQUEST_TIMEOUT_MS$2), Effect.catchCause((cause) => Effect.fail(new McpToolCallError({
 		detail: `Could not reach ${input.url}: ${String(cause)}`,
 		status: null
 	}))));
@@ -37791,6 +38019,14 @@ const callMcpTool = Effect.fn("McpToolClient.callMcpTool")(function* (input) {
 		text
 	};
 });
+/**
+* Linear's own tool for reading one issue.
+*
+* Named here rather than at each call site because two of them are now in
+* different modules - the board's store and the mirror refresh - and a tool
+* name that drifts between them fails at runtime with a shrug from the server.
+*/
+const LINEAR_GET_ISSUE_TOOL = "get_issue";
 /** Why a Linear call could not be made, in terms a person can act on. */
 var LinearUnavailable = class extends Schema$1.TaggedErrorClass()("LinearUnavailable", {
 	reason: Schema$1.Literals([
@@ -37804,8 +38040,8 @@ var LinearUnavailable = class extends Schema$1.TaggedErrorClass()("LinearUnavail
 		return this.detail;
 	}
 };
-const asRecord$3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-const asArray = (value) => Array.isArray(value) ? value : void 0;
+const asRecord$4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+const asArray$1 = (value) => Array.isArray(value) ? value : void 0;
 /**
 * Find the payload inside whatever the tool returned.
 *
@@ -37833,23 +38069,23 @@ const readPayload$1 = (result) => {
 * pagination scalars beside it.
 */
 const readRows = (payload) => {
-	const direct = asArray(payload);
-	if (direct !== void 0) return direct.map(asRecord$3).filter((row) => row !== void 0);
-	const record = asRecord$3(payload);
+	const direct = asArray$1(payload);
+	if (direct !== void 0) return direct.map(asRecord$4).filter((row) => row !== void 0);
+	const record = asRecord$4(payload);
 	if (record === void 0) return [];
 	for (const value of Object.values(record)) {
-		const rows = asArray(value);
-		if (rows !== void 0) return rows.map(asRecord$3).filter((row) => row !== void 0);
+		const rows = asArray$1(value);
+		if (rows !== void 0) return rows.map(asRecord$4).filter((row) => row !== void 0);
 	}
 	return [];
 };
 /** The single object out of a result, unwrapping one level of nesting. */
 const readOne = (payload) => {
-	const record = asRecord$3(payload);
+	const record = asRecord$4(payload);
 	if (record === void 0) return;
 	if (record["id"] !== void 0 || record["identifier"] !== void 0) return record;
 	for (const value of Object.values(record)) {
-		const nested = asRecord$3(value);
+		const nested = asRecord$4(value);
 		if (nested?.["id"] !== void 0) return nested;
 	}
 };
@@ -37908,6 +38144,463 @@ const makeLinearMcpClient = Effect.gen(function* () {
 });
 const LinearMcpClientLive = Layer.effect(LinearMcpClient, makeLinearMcpClient);
 //#endregion
+//#region src/tracker/TrackerSecrets.ts
+const secretName = (provider) => `tracker.${provider}.apiKey`;
+var TrackerSecrets = class extends Context.Service()("@p4code/cli/tracker/TrackerSecrets") {};
+const decodeCredential = (bytes) => {
+	try {
+		const parsed = JSON.parse(new TextDecoder().decode(bytes));
+		if (typeof parsed !== "object" || parsed === null) return void 0;
+		const record = parsed;
+		const apiKey = record["apiKey"];
+		if (typeof apiKey !== "string" || apiKey.length === 0) return void 0;
+		const workspace = record["workspace"];
+		return {
+			apiKey,
+			workspace: typeof workspace === "string" ? workspace : null
+		};
+	} catch {
+		return;
+	}
+};
+const makeTrackerSecrets = Effect.gen(function* () {
+	const store = yield* ServerSecretStore;
+	const read = (provider) => store.get(secretName(provider)).pipe(Effect.map(Option.match({
+		onNone: () => Option.none(),
+		onSome: (value) => Option.fromNullishOr(decodeCredential(value))
+	})), Effect.orElseSucceed(() => Option.none()));
+	const write = (provider, credential) => store.set(secretName(provider), new TextEncoder().encode(JSON.stringify(credential)));
+	const clear = (provider) => store.remove(secretName(provider));
+	return {
+		read,
+		write,
+		clear
+	};
+});
+const TrackerSecretsLive = Layer.effect(TrackerSecrets, makeTrackerSecrets);
+//#endregion
+//#region src/tracker/graphqlRequest.ts
+/**
+* One GraphQL POST, for any tracker that speaks it.
+*
+* Shared by design rather than folded into the Linear client: the next
+* tracker with a GraphQL API gets its transport from here and writes only its
+* queries. Deliberately minimal for the same reason `McpToolClient` is - no
+* retries, no batching, no persisted queries - one request, one parsed body.
+*
+* Transport failures and HTTP statuses fail the effect; GraphQL-level errors
+* do not. A body with `errors` beside partial `data` is a real answer some
+* calls expect - Linear reports a missing issue exactly that way - and only
+* the caller knows which errors mean "not found" and which mean "broken".
+*
+* @module tracker/graphqlRequest
+*/
+const REQUEST_TIMEOUT_MS$1 = 15e3;
+var GraphqlRequestError = class extends Schema$1.TaggedErrorClass()("GraphqlRequestError", {
+	detail: Schema$1.String,
+	status: Schema$1.NullOr(Schema$1.Number)
+}) {
+	get message() {
+		return this.detail;
+	}
+};
+const asRecord$3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+const errorMessages = (value) => {
+	if (!Array.isArray(value)) return [];
+	return value.map((entry) => asRecord$3(entry)?.["message"]).filter((message) => typeof message === "string");
+};
+const parseJsonRecord = (text) => {
+	try {
+		return asRecord$3(JSON.parse(text));
+	} catch {
+		return;
+	}
+};
+const graphqlRequest = Effect.fn("tracker/graphqlRequest")(function* (input) {
+	const response = yield* (yield* HttpClient$1.HttpClient).execute(HttpClientRequest$1.bodyJsonUnsafe(HttpClientRequest$1.setHeaders(HttpClientRequest$1.post(input.url), input.headers), {
+		query: input.query,
+		variables: input.variables ?? {}
+	})).pipe(Effect.timeout(REQUEST_TIMEOUT_MS$1), Effect.catchCause((cause) => Effect.fail(new GraphqlRequestError({
+		detail: `Could not reach ${input.url}: ${String(cause)}`,
+		status: null
+	}))));
+	const body = yield* response.text.pipe(Effect.catchCause(() => Effect.succeed("")));
+	if (response.status >= 400) return yield* new GraphqlRequestError({
+		detail: response.status === 401 || response.status === 403 ? "The server rejected the credential." : `The server answered ${response.status}.`,
+		status: response.status
+	});
+	const record = parseJsonRecord(body);
+	if (record === void 0) return yield* new GraphqlRequestError({
+		detail: "The server's answer was not a GraphQL response.",
+		status: response.status
+	});
+	return {
+		data: asRecord$3(record["data"]),
+		errors: errorMessages(record["errors"])
+	};
+});
+//#endregion
+//#region src/tracker/LinearApiClient.ts
+/**
+* Linear over its own GraphQL API, wearing the MCP tool vocabulary.
+*
+* This speaks the same three "tools" the Linear MCP server offers -
+* `list_issues`, `get_issue`, `save_issue` - and answers in the same row
+* shapes, so `LinearTasks` and the resolver cannot tell which transport
+* served them. That is the point: the MCP server remains the fallback, and a
+* consumer that could tell the two apart would need two code paths.
+*
+* The one real difference is hidden here: the MCP tools accept names where
+* the API wants ids - a team's key, a state's type, a person's display name -
+* so a write first resolves names to ids with lookup queries. A name that
+* resolves to nothing fails with a sentence naming it, which is the same
+* answer the MCP server gives, not a silent skip.
+*
+* @module tracker/LinearApiClient
+*/
+const LINEAR_GRAPHQL_URL = "https://api.linear.app/graphql";
+/**
+* Every field a board card or a resolved ticket reads, fetched on every
+* query. The MCP server's `list_issues` takes a field selector; here the
+* selection is fixed and complete, because the cost of a spare field is
+* nothing next to the cost of a card that quietly lost its assignee.
+*/
+const ISSUE_SELECTION = `
+  id
+  identifier
+  title
+  description
+  url
+  priority
+  createdAt
+  updatedAt
+  state { name type }
+  assignee { displayName name email }
+  labels { nodes { name } }
+  parent { id }
+`;
+/** Linear's state types, which `save_issue` accepts in place of a state name. */
+const STATE_TYPES = /* @__PURE__ */ new Set([
+	"triage",
+	"backlog",
+	"unstarted",
+	"started",
+	"completed",
+	"canceled"
+]);
+const asRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+const asArray = (value) => Array.isArray(value) ? value : [];
+const asString = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+/**
+* One issue node, flattened to the row shape the MCP tools answer with, which
+* is the shape `taskFromLinearIssue` reads: state pulled apart into
+* `status`/`statusType`, the parent reduced to its id. `assignee` and
+* `labels` stay structured - the mapping already accepts both forms.
+*/
+const toIssueRow = (node) => {
+	const state = asRecord$2(node["state"]);
+	const parent = asRecord$2(node["parent"]);
+	const labels = asRecord$2(node["labels"]);
+	return {
+		id: node["id"],
+		identifier: node["identifier"],
+		title: node["title"],
+		description: node["description"],
+		url: node["url"],
+		priority: node["priority"],
+		createdAt: node["createdAt"],
+		updatedAt: node["updatedAt"],
+		status: state?.["name"],
+		statusType: state?.["type"],
+		assignee: node["assignee"],
+		labels: labels === void 0 ? [] : asArray(labels["nodes"]),
+		parentId: parent?.["id"]
+	};
+};
+/** A case-insensitive equality filter over the ways a person is named. */
+const personFilter = (person) => ({ or: [
+	{ displayName: { eqIgnoreCase: person } },
+	{ name: { eqIgnoreCase: person } },
+	{ email: { eqIgnoreCase: person } }
+] });
+const makeLinearApiTransport = Effect.gen(function* () {
+	const secrets = yield* TrackerSecrets;
+	const http = yield* HttpClient$1.HttpClient;
+	const request = (apiKey, query, variables) => graphqlRequest({
+		url: LINEAR_GRAPHQL_URL,
+		headers: { authorization: apiKey },
+		query,
+		...variables === void 0 ? {} : { variables }
+	}).pipe(Effect.provideService(HttpClient$1.HttpClient, http), Effect.mapError((error) => error.status === 401 || error.status === 403 ? new LinearUnavailable({
+		reason: "not_authorized",
+		detail: "Linear rejected the stored API key. Update it in Settings."
+	}) : new LinearUnavailable({
+		reason: "failed",
+		detail: error.detail
+	})));
+	/** The one entity out of `data`, or a failure carrying Linear's own words. */
+	const readEntity = (response, key) => {
+		const entity = asRecord$2(response.data?.[key]);
+		if (entity !== void 0) return Effect.succeed(entity);
+		if (response.errors.length === 0) return Effect.succeed(void 0);
+		if (response.errors.some((message) => /not found|does not exist/iu.test(message))) return Effect.succeed(void 0);
+		return Effect.fail(new LinearUnavailable({
+			reason: "failed",
+			detail: response.errors.join("; ")
+		}));
+	};
+	const nodesOf = (response, key) => asArray(asRecord$2(response.data?.[key])?.["nodes"]).map(asRecord$2).filter((node) => node !== void 0);
+	const resolveTeamId = (apiKey, team) => Effect.gen(function* () {
+		const response = yield* request(apiKey, `query($filter: TeamFilter) { teams(filter: $filter, first: 2) { nodes { id } } }`, { filter: { or: [{ key: { eqIgnoreCase: team } }, { name: { eqIgnoreCase: team } }] } });
+		const id = asString(nodesOf(response, "teams")[0]?.["id"]);
+		if (id === void 0) return yield* new LinearUnavailable({
+			reason: "failed",
+			detail: `Linear has no team whose key or name is "${team}".`
+		});
+		return id;
+	});
+	const teamIdOfIssue = (apiKey, issueId) => Effect.gen(function* () {
+		const response = yield* request(apiKey, `query($id: String!) { issue(id: $id) { team { id } } }`, { id: issueId });
+		const issue = yield* readEntity(response, "issue");
+		const id = asString(asRecord$2(issue?.["team"])?.["id"]);
+		if (id === void 0) return yield* new LinearUnavailable({
+			reason: "failed",
+			detail: `Linear has no issue "${issueId}" to read a team from.`
+		});
+		return id;
+	});
+	/**
+	* The state a write should land in, given a type, a name or an id - the
+	* three things `save_issue` accepts.
+	*
+	* When a type names several states, the first by the team's own ordering
+	* wins, except that `started` skips review-named states: a team's "In
+	* Review" is a `started` state by type, and landing `in_progress` writes in
+	* the review column is precisely the mixup the by-name special case in
+	* `linearTaskMapping` exists to avoid.
+	*/
+	const resolveStateId = (apiKey, teamId, state) => Effect.gen(function* () {
+		const response = yield* request(apiKey, `query($filter: WorkflowStateFilter) {
+          workflowStates(filter: $filter, first: 100) { nodes { id name type position } }
+        }`, { filter: { team: { id: { eq: teamId } } } });
+		const states = [...nodesOf(response, "workflowStates")].sort((a, b) => (Number(a["position"]) || 0) - (Number(b["position"]) || 0));
+		const wanted = state.toLowerCase();
+		const match = STATE_TYPES.has(wanted) ? states.find((candidate) => candidate["type"] === wanted && !(wanted === "started" && /review/iu.test(asString(candidate["name"]) ?? ""))) ?? states.find((candidate) => candidate["type"] === wanted) : states.find((candidate) => (asString(candidate["name"]) ?? "").toLowerCase() === wanted) ?? states.find((candidate) => candidate["id"] === state);
+		const id = asString(match?.["id"]);
+		if (id === void 0) return yield* new LinearUnavailable({
+			reason: "failed",
+			detail: `The team has no Linear state matching "${state}".`
+		});
+		return id;
+	});
+	const resolveAssigneeId = (apiKey, person) => Effect.gen(function* () {
+		const response = yield* request(apiKey, `query($filter: UserFilter) { users(filter: $filter, first: 2) { nodes { id } } }`, { filter: personFilter(person) });
+		const id = asString(nodesOf(response, "users")[0]?.["id"]);
+		if (id === void 0) return yield* new LinearUnavailable({
+			reason: "failed",
+			detail: `Linear has no user matching "${person}".`
+		});
+		return id;
+	});
+	const resolveLabelIds = (apiKey, labels) => Effect.gen(function* () {
+		if (labels.length === 0) return [];
+		const response = yield* request(apiKey, `query($filter: IssueLabelFilter) { issueLabels(filter: $filter, first: 250) { nodes { id name } } }`, { filter: { or: labels.map((label) => ({ name: { eqIgnoreCase: label } })) } });
+		const byName = new Map(nodesOf(response, "issueLabels").map((node) => [(asString(node["name"]) ?? "").toLowerCase(), asString(node["id"])]));
+		const missing = labels.filter((label) => byName.get(label.toLowerCase()) === void 0);
+		if (missing.length > 0) return yield* new LinearUnavailable({
+			reason: "failed",
+			detail: `Linear has no label named ${missing.map((label) => `"${label}"`).join(", ")}.`
+		});
+		return labels.map((label) => byName.get(label.toLowerCase())).filter((id) => id !== void 0);
+	});
+	const listIssues = (apiKey, args) => Effect.gen(function* () {
+		const team = asString(args["team"]);
+		const state = asString(args["state"]);
+		const assignee = asString(args["assignee"]);
+		const filter = {
+			...team === void 0 ? {} : { team: { or: [{ key: { eqIgnoreCase: team } }, { name: { eqIgnoreCase: team } }] } },
+			...state === void 0 ? {} : STATE_TYPES.has(state.toLowerCase()) ? { state: { type: { eq: state.toLowerCase() } } } : { state: { name: { eqIgnoreCase: state } } },
+			...assignee === void 0 ? {} : { assignee: personFilter(assignee) }
+		};
+		const response = yield* request(apiKey, `query($first: Int!, $includeArchived: Boolean!, $filter: IssueFilter) {
+          issues(first: $first, includeArchived: $includeArchived, filter: $filter, orderBy: updatedAt) {
+            nodes { ${ISSUE_SELECTION} }
+          }
+        }`, {
+			first: typeof args["limit"] === "number" ? args["limit"] : 250,
+			includeArchived: args["includeArchived"] !== false,
+			filter
+		});
+		if (response.data === void 0 && response.errors.length > 0) return yield* new LinearUnavailable({
+			reason: "failed",
+			detail: response.errors.join("; ")
+		});
+		return { issues: nodesOf(response, "issues").map(toIssueRow) };
+	});
+	const getIssue = (apiKey, args) => Effect.gen(function* () {
+		const id = asString(args["id"]);
+		if (id === void 0) return yield* new LinearUnavailable({
+			reason: "failed",
+			detail: "get_issue needs an id."
+		});
+		const response = yield* request(apiKey, `query($id: String!) { issue(id: $id) { ${ISSUE_SELECTION} } }`, { id });
+		const issue = yield* readEntity(response, "issue");
+		return issue === void 0 ? {} : toIssueRow(issue);
+	});
+	const saveIssue = (apiKey, args) => Effect.gen(function* () {
+		const issueId = asString(args["id"]);
+		const team = asString(args["team"]);
+		const state = asString(args["state"]);
+		const input = {
+			...asString(args["title"]) === void 0 ? {} : { title: args["title"] },
+			...typeof args["description"] === "string" ? { description: args["description"] } : {},
+			...typeof args["priority"] === "number" ? { priority: args["priority"] } : {},
+			..."parentId" in args ? { parentId: args["parentId"] } : {}
+		};
+		if (issueId === void 0 && team === void 0) return yield* new LinearUnavailable({
+			reason: "failed",
+			detail: "save_issue needs an id to update or a team to create in."
+		});
+		if (state !== void 0) {
+			const teamId = issueId === void 0 ? yield* resolveTeamId(apiKey, team ?? "") : yield* teamIdOfIssue(apiKey, issueId);
+			input["stateId"] = yield* resolveStateId(apiKey, teamId, state);
+		}
+		if (issueId === void 0 && team !== void 0) input["teamId"] = yield* resolveTeamId(apiKey, team);
+		if ("assignee" in args) {
+			const person = asString(args["assignee"]);
+			input["assigneeId"] = person === void 0 ? null : yield* resolveAssigneeId(apiKey, person);
+		}
+		if (Array.isArray(args["labels"])) input["labelIds"] = yield* resolveLabelIds(apiKey, args["labels"].filter((label) => typeof label === "string"));
+		const response = issueId === void 0 ? yield* request(apiKey, `mutation($input: IssueCreateInput!) {
+                issueCreate(input: $input) { issue { ${ISSUE_SELECTION} } }
+              }`, { input }) : yield* request(apiKey, `mutation($id: String!, $input: IssueUpdateInput!) {
+                issueUpdate(id: $id, input: $input) { issue { ${ISSUE_SELECTION} } }
+              }`, {
+			id: issueId,
+			input
+		});
+		const payload = yield* readEntity(response, issueId === void 0 ? "issueCreate" : "issueUpdate");
+		const issue = asRecord$2(payload?.["issue"]);
+		if (issue === void 0) return yield* new LinearUnavailable({
+			reason: "failed",
+			detail: response.errors.length > 0 ? response.errors.join("; ") : "Linear accepted the write but returned no issue."
+		});
+		return toIssueRow(issue);
+	});
+	const isConfigured = secrets.read("linear").pipe(Effect.map((credential) => Option.isSome(credential)));
+	const call = (toolName, args) => Effect.gen(function* () {
+		const credential = yield* secrets.read("linear");
+		if (Option.isNone(credential)) return yield* new LinearUnavailable({
+			reason: "not_configured",
+			detail: "No Linear API key is stored on this machine. Add one in Settings."
+		});
+		const apiKey = credential.value.apiKey;
+		switch (toolName) {
+			case "list_issues": return yield* listIssues(apiKey, args);
+			case "get_issue": return yield* getIssue(apiKey, args);
+			case "save_issue": return yield* saveIssue(apiKey, args);
+			default: return yield* new LinearUnavailable({
+				reason: "failed",
+				detail: `The Linear API transport has no translation for "${toolName}".`
+			});
+		}
+	});
+	const verify = (apiKey) => Effect.gen(function* () {
+		const response = yield* request(apiKey, `query { viewer { id } organization { name urlKey } }`).pipe(Effect.mapError((error) => error.reason === "not_authorized" ? new LinearUnavailable({
+			reason: "not_authorized",
+			detail: "Linear rejected this API key."
+		}) : error));
+		if (asString(asRecord$2(response.data?.["viewer"])?.["id"]) === void 0) return yield* new LinearUnavailable({
+			reason: "not_authorized",
+			detail: response.errors.length > 0 ? response.errors.join("; ") : "Linear rejected this API key."
+		});
+		const organization = asRecord$2(response.data?.["organization"]);
+		return { workspace: asString(organization?.["name"]) ?? asString(organization?.["urlKey"]) ?? null };
+	});
+	return {
+		isConfigured,
+		call,
+		verify
+	};
+});
+//#endregion
+//#region src/tracker/LinearClient.ts
+/**
+* Linear, by whichever transport this machine has.
+*
+* Two transports exist: the GraphQL API behind a p4code-held key, and the MCP
+* server the user registered. The key wins whenever one is stored - it is the
+* transport p4code verified the moment it was entered - and the MCP path
+* remains the fallback, so a machine that never entered a key behaves exactly
+* as it always has.
+*
+* Chosen per call rather than at startup: a key can be entered or cleared in
+* Settings while the server runs, and a client captured at construction would
+* keep answering from a credential that no longer exists.
+*
+* Every consumer - the board, the resolver, the settings panel - talks to
+* this and never to a transport directly, which is what keeps "connected to
+* Linear" meaning one thing.
+*
+* @module tracker/LinearClient
+*/
+var LinearClient = class extends Context.Service()("@p4code/cli/tracker/LinearClient") {};
+const makeLinearClient = Effect.gen(function* () {
+	const secrets = yield* TrackerSecrets;
+	const api = yield* makeLinearApiTransport;
+	const mcp = yield* LinearMcpClient;
+	const storedCredential = secrets.read("linear");
+	const isConfigured = Effect.gen(function* () {
+		if (Option.isSome(yield* storedCredential)) return true;
+		return yield* mcp.isConfigured;
+	});
+	const call = (toolName, args) => Effect.gen(function* () {
+		const credential = yield* storedCredential;
+		return Option.isSome(credential) ? yield* api.call(toolName, args) : yield* mcp.call(toolName, args);
+	});
+	const status = Effect.gen(function* () {
+		const credential = yield* storedCredential;
+		if (Option.isSome(credential)) return {
+			provider: "linear",
+			mode: "api",
+			workspace: credential.value.workspace
+		};
+		return {
+			provider: "linear",
+			mode: (yield* mcp.isConfigured) ? "mcp" : "none",
+			workspace: null
+		};
+	});
+	const setApiKey = (apiKey) => Effect.gen(function* () {
+		const verified = yield* api.verify(apiKey).pipe(Effect.mapError((cause) => new TrackerApiKeyError({
+			reason: cause.reason === "not_authorized" ? "invalid_key" : "unavailable",
+			detail: cause.detail
+		})));
+		yield* secrets.write("linear", {
+			apiKey,
+			workspace: verified.workspace
+		}).pipe(Effect.mapError((cause) => new TrackerApiKeyError({
+			reason: "unavailable",
+			detail: `The key was verified but could not be stored: ${cause.message}`
+		})));
+		return yield* status;
+	});
+	return {
+		isConfigured,
+		call,
+		status,
+		setApiKey,
+		clearApiKey: Effect.gen(function* () {
+			yield* secrets.clear("linear").pipe(Effect.mapError((cause) => new TrackerApiKeyError({
+				reason: "unavailable",
+				detail: `The stored key could not be removed: ${cause.message}`
+			})));
+			return yield* status;
+		})
+	};
+});
+const LinearClientLive = Layer.effect(LinearClient, makeLinearClient);
+//#endregion
 //#region ../../packages/shared/src/ticketReference.ts
 /**
 * Recognizing a tracker reference in text somebody pasted.
@@ -38022,7 +38715,7 @@ const STATUS_FROM_LINEAR_TYPE = {
 	completed: "done",
 	canceled: "cancelled"
 };
-const asRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+const asRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 const text = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
 /**
 * A person's name out of whatever Linear put in the field: an object when the
@@ -38031,14 +38724,14 @@ const text = (value) => typeof value === "string" && value.trim().length > 0 ? v
 const personName = (value) => {
 	const direct = text(value);
 	if (direct !== void 0) return direct;
-	const record = asRecord$2(value);
+	const record = asRecord$1(value);
 	if (record === void 0) return null;
 	return text(record["displayName"]) ?? text(record["name"]) ?? text(record["email"]) ?? null;
 };
 /** Label names, from either `["Bug"]` or `[{ name: "Bug" }]`. */
 const labelNames = (value) => {
 	if (!Array.isArray(value)) return [];
-	return value.map((entry) => text(entry) ?? text(asRecord$2(entry)?.["name"])).filter((name) => name !== void 0);
+	return value.map((entry) => text(entry) ?? text(asRecord$1(entry)?.["name"])).filter((name) => name !== void 0);
 };
 /**
 * The p4code status an issue is in.
@@ -38083,7 +38776,7 @@ const statusToLinearState = (status) => {
 * Medium, and quietly rewrite the local row with it.
 */
 const priorityFromLinear = (value) => {
-	const numeric = typeof value === "number" ? value : asRecord$2(value)?.["value"];
+	const numeric = typeof value === "number" ? value : asRecord$1(value)?.["value"];
 	return typeof numeric === "number" ? PRIORITY_FROM_LINEAR[numeric] ?? "none" : "none";
 };
 const priorityToLinear = (priority) => PRIORITY_TO_LINEAR[priority];
@@ -38175,7 +38868,7 @@ const linearFailed = (operation, cause) => new PersistenceSqlError({
 });
 const makeLinearTaskRepository = Effect.gen(function* () {
 	const sql = yield* SqlClient.SqlClient;
-	const linear = yield* LinearMcpClient;
+	const linear = yield* LinearClient;
 	const settings = yield* ServerSettingsService;
 	const changes = yield* PubSub.unbounded();
 	const publish = (event) => PubSub.publish(changes, event).pipe(Effect.asVoid);
@@ -38912,7 +39605,7 @@ const makeRegistry = Effect.gen(function* () {
 	const linear = yield* makeLinearTaskRepository;
 	return {
 		forSource: (source) => source === "linear" ? linear : board,
-		linearAvailable: (yield* LinearMcpClient).isConfigured
+		linearAvailable: (yield* LinearClient).isConfigured
 	};
 });
 const TaskRepositoryRegistryLive = Layer.effect(TaskRepositoryRegistry, makeRegistry);
@@ -57931,6 +58624,7 @@ const RPC_REQUIRED_SCOPE = /* @__PURE__ */ new Map([
 	[ORCHESTRATION_WS_METHODS.dispatchCommand, AuthOrchestrationOperateScope],
 	[ORCHESTRATION_WS_METHODS.getTurnDiff, AuthOrchestrationReadScope],
 	[ORCHESTRATION_WS_METHODS.getFullThreadDiff, AuthOrchestrationReadScope],
+	[ORCHESTRATION_WS_METHODS.searchThreads, AuthOrchestrationReadScope],
 	[ORCHESTRATION_WS_METHODS.subscribeShell, AuthOrchestrationReadScope],
 	[ORCHESTRATION_WS_METHODS.getArchivedShellSnapshot, AuthOrchestrationReadScope],
 	[ORCHESTRATION_WS_METHODS.subscribeThread, AuthOrchestrationReadScope],
@@ -57971,6 +58665,9 @@ const RPC_REQUIRED_SCOPE = /* @__PURE__ */ new Map([
 	[WS_METHODS.mcpSetSecret, AuthOrchestrationOperateScope],
 	[WS_METHODS.mcpOAuthBegin, AuthOrchestrationOperateScope],
 	[WS_METHODS.mcpOAuthDisconnect, AuthOrchestrationOperateScope],
+	[WS_METHODS.trackerStatus, AuthOrchestrationReadScope],
+	[WS_METHODS.trackerSetApiKey, AuthOrchestrationOperateScope],
+	[WS_METHODS.trackerClearApiKey, AuthOrchestrationOperateScope],
 	[WS_METHODS.serverGetSettings, AuthOrchestrationReadScope],
 	[WS_METHODS.serverUpdateSettings, AuthOrchestrationOperateScope],
 	[WS_METHODS.serverDiscoverSourceControl, AuthOrchestrationReadScope],
@@ -58117,6 +58814,7 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 	const assetSync = yield* AssetSync;
 	const mcpRegistry = yield* McpRegistry;
 	const mcpOAuth = yield* McpOAuth;
+	const linearClient = yield* LinearClient;
 	const claudeMcpFiles = yield* ClaudeMcpFiles;
 	const skillRegistry = yield* SkillRegistry;
 	const listMcpServersEverywhere = Effect.gen(function* () {
@@ -58493,6 +59191,10 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 			message: "Failed to load full thread diff",
 			cause
 		}))), { "rpc.aggregate": "orchestration" }),
+		[ORCHESTRATION_WS_METHODS.searchThreads]: (input) => observeRpcEffect$1(ORCHESTRATION_WS_METHODS.searchThreads, projectionSnapshotQuery.searchThreads(input).pipe(Effect.mapError((cause) => new OrchestrationSearchThreadsError({
+			message: "Failed to search threads",
+			cause
+		}))), { "rpc.aggregate": "orchestration" }),
 		[ORCHESTRATION_WS_METHODS.subscribeShell]: (input) => observeRpcStreamEffect$1(ORCHESTRATION_WS_METHODS.subscribeShell, Effect.gen(function* () {
 			const liveBuffer = yield* Queue.unbounded();
 			yield* Effect.forkScoped(orchestrationEngine.streamDomainEvents.pipe(Stream.runForEach((event) => Queue.offer(liveBuffer, {
@@ -58770,6 +59472,9 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 			return yield* mcpOAuth.begin(found.registration);
 		}), { "rpc.aggregate": "mcp" }),
 		[WS_METHODS.mcpOAuthDisconnect]: ({ name }) => observeRpcEffect$1(WS_METHODS.mcpOAuthDisconnect, mcpOAuth.disconnect(name).pipe(Effect.andThen(listMcpServersEverywhere)), { "rpc.aggregate": "mcp" }),
+		[WS_METHODS.trackerStatus]: (_input) => observeRpcEffect$1(WS_METHODS.trackerStatus, linearClient.status, { "rpc.aggregate": "tracker" }),
+		[WS_METHODS.trackerSetApiKey]: ({ apiKey }) => observeRpcEffect$1(WS_METHODS.trackerSetApiKey, linearClient.setApiKey(apiKey), { "rpc.aggregate": "tracker" }),
+		[WS_METHODS.trackerClearApiKey]: (_input) => observeRpcEffect$1(WS_METHODS.trackerClearApiKey, linearClient.clearApiKey, { "rpc.aggregate": "tracker" }),
 		[WS_METHODS.serverGetSettings]: (_input) => observeRpcEffect$1(WS_METHODS.serverGetSettings, serverSettings.getSettings.pipe(Effect.map(redactServerSettingsForClient)), { "rpc.aggregate": "server" }),
 		[WS_METHODS.serverUpdateSettings]: ({ patch }) => observeRpcEffect$1(WS_METHODS.serverUpdateSettings, serverSettings.updateSettings(patch).pipe(Effect.map(redactServerSettingsForClient)), { "rpc.aggregate": "server" }),
 		[WS_METHODS.serverDiscoverSourceControl]: (_input) => observeRpcEffect$1(WS_METHODS.serverDiscoverSourceControl, sourceControlDiscovery.discover, { "rpc.aggregate": "server" }),
@@ -62578,6 +63283,18 @@ function normalizeClaudeStreamMessages(cause) {
 	const squashed = toMessage(Cause.squash(cause), "").trim();
 	return squashed.length > 0 ? [squashed] : [];
 }
+const CLAUDE_MISSING_PATH_PATTERN = /path "([^"]+)" does not exist/i;
+/**
+* Raw cause text never reaches a runtime event: it is CLI output that can carry
+* credential material, which is why the event payload stays structural. But the
+* wrapper detail alone ("Claude runtime stream failed.") reads the same whether
+* the CLI crashed or the thread's directory was deleted, so recognized failure
+* shapes get a curated sentence built from matched fragments only.
+*/
+function describeProcessFailure(failure) {
+	const missingPath = CLAUDE_MISSING_PATH_PATTERN.exec(toMessage(failure.cause, ""))?.[1];
+	return missingPath === void 0 ? failure.detail : `${failure.detail} Directory does not exist: ${missingPath}`;
+}
 function getEffectiveClaudeAgentEffort(effort, model) {
 	const normalized = normalizeClaudeCliEffort(effort, model);
 	return normalized ? normalized : null;
@@ -64683,7 +65400,8 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			if (context.turnState) yield* completeTurn(context, "interrupted", "Claude runtime interrupted.");
 		} else {
 			const failures = exit.cause.reasons.flatMap((reason) => Cause.isFailReason(reason) ? [reason.error] : []);
-			const message = failures[0]?.detail ?? "Claude runtime stream failed.";
+			const firstFailure = failures[0];
+			const message = firstFailure === void 0 ? "Claude runtime stream failed." : describeProcessFailure(firstFailure);
 			yield* emitRuntimeError(context, message, {
 				failureCount: failures.length,
 				failureTags: failures.map((failure) => failure._tag)
@@ -64776,6 +65494,13 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			operation: "startSession",
 			issue: `Expected provider '${PROVIDER$6}' but received '${input.provider}'.`
 		});
+		if (input.cwd !== void 0 && input.cwd.length > 0) {
+			if (!(yield* fileSystem.exists(input.cwd).pipe(Effect.orElseSucceed(() => false)))) return yield* new ProviderAdapterValidationError({
+				provider: PROVIDER$6,
+				operation: "startSession",
+				issue: `Working directory does not exist: ${input.cwd}`
+			});
+		}
 		const existingContext = sessions.get(input.threadId);
 		if (existingContext) {
 			yield* Effect.logWarning("claude.session.replacing", {
@@ -90132,7 +90857,7 @@ const layerChildProcess = (handle, options = {}) => {
 };
 //#endregion
 //#region ../../packages/shared/src/toolActivity.ts
-function asRecord$1(value) {
+function asRecord(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 function asTrimmedString(value) {
@@ -90162,10 +90887,10 @@ function extractCommandFromTitle$1(title) {
 	return /`([^`]+)`/u.exec(title)?.[1]?.trim() || void 0;
 }
 function extractToolCommand(data, title) {
-	const item = asRecord$1(data?.item);
-	const itemInput = asRecord$1(item?.input);
-	const itemResult = asRecord$1(item?.result);
-	const rawInput = asRecord$1(data?.rawInput);
+	const item = asRecord(data?.item);
+	const itemInput = asRecord(item?.input);
+	const itemResult = asRecord(item?.result);
+	const rawInput = asRecord(data?.rawInput);
 	const direct = [
 		normalizeCommandValue$1(item?.command),
 		normalizeCommandValue$1(itemInput?.command),
@@ -90193,7 +90918,7 @@ function collectPaths(value, paths, seen, depth) {
 		}
 		return;
 	}
-	const record = asRecord$1(value);
+	const record = asRecord(value);
 	if (!record) return;
 	for (const key of [
 		"path",
@@ -90252,7 +90977,7 @@ function deriveToolActivityPresentation(input) {
 	const title = asTrimmedString(input.title);
 	const detail = stripTrailingExitCode(asTrimmedString(input.detail));
 	const fallbackSummary = asTrimmedString(input.fallbackSummary) ?? "Tool";
-	const data = asRecord$1(input.data);
+	const data = asRecord(input.data);
 	const command = extractToolCommand(data, title);
 	const primaryPath = extractPrimaryPath(data);
 	const action = classifyToolAction({
@@ -90276,7 +91001,7 @@ function deriveToolActivityPresentation(input) {
 		...primaryPath ? { detail: primaryPath } : {}
 	};
 	if (action === "search") {
-		const query = asTrimmedString(asRecord$1(data?.rawInput)?.query) ?? asTrimmedString(asRecord$1(data?.rawInput)?.pattern) ?? asTrimmedString(asRecord$1(data?.rawInput)?.searchTerm);
+		const query = asTrimmedString(asRecord(data?.rawInput)?.query) ?? asTrimmedString(asRecord(data?.rawInput)?.pattern) ?? asTrimmedString(asRecord(data?.rawInput)?.searchTerm);
 		return {
 			summary: "Searched files",
 			...query ? { detail: query } : {}
@@ -98279,84 +99004,23 @@ const PreviewSnapshotToolkitHandlersLive = PreviewSnapshotToolkit.toLayer({ prev
 PreviewToolkit.toLayer(handlers$3);
 //#endregion
 //#region src/mcp/TicketResolver.ts
-/**
-* The registered server name a Linear ticket is resolved through.
-*
-* Matched by name rather than by URL: the name is what the user typed in
-* Settings and what every other surface calls it, and a workspace may reach
-* Linear through a proxy URL that no pattern here would recognize.
-*/
-const LINEAR_SERVER_NAME = "linear";
-/** Linear's own tool for reading one issue. */
-const LINEAR_GET_ISSUE_TOOL = "get_issue";
 var TicketResolver = class extends Context.Service()("@p4code/cli/mcp/TicketResolver") {};
 const stringField = (record, key) => {
 	const value = record[key];
 	return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
 };
-const asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-/**
-* Find the issue inside whatever the tool returned.
-*
-* MCP leaves the shape of a tool result to the tool, so this accepts the three
-* arrangements in the wild - the structured payload itself, that payload with
-* the issue nested one level down, or a text block that happens to be JSON -
-* rather than assuming the one Linear happens to send today.
-*/
-const readIssue = (result) => {
-	const structured = asRecord(result.structuredContent);
-	if (structured !== void 0) {
-		const nested = asRecord(structured["issue"]);
-		if (nested !== void 0) return nested;
-		if (stringField(structured, "url") !== void 0) return structured;
-	}
-	try {
-		const parsed = JSON.parse(result.text);
-		const record = asRecord(parsed);
-		if (record === void 0) return structured;
-		return asRecord(record["issue"]) ?? record;
-	} catch {
-		return structured;
-	}
-};
 const make$4 = Effect.gen(function* () {
-	const registry = yield* McpRegistry;
-	const oauth = yield* McpOAuth;
-	const http = yield* HttpClient$1.HttpClient;
+	const linear = yield* LinearClient;
 	return { resolve: Effect.fn("TicketResolver.resolve")(function* (reference) {
 		const identifier = parseTicketReference(reference);
 		if (identifier === null) return yield* new TicketResolveError({
 			reason: "not_found",
 			detail: `"${reference}" does not look like a ticket reference.`
 		});
-		const server = (yield* registry.list).find((candidate) => candidate.registration.name.toLowerCase() === LINEAR_SERVER_NAME && candidate.registration.enabled);
-		if (server === void 0 || server.registration.transport === "stdio") return yield* new TicketResolveError({
-			reason: "not_configured",
-			detail: "No Linear MCP server is registered on this machine. Add it in Settings to link tickets."
-		});
-		const registration = server.registration;
-		const token = yield* oauth.accessTokenFor(registration);
-		const headers = {
-			...registration.headers,
-			...Option.isSome(token) ? { authorization: `Bearer ${token.value}` } : {}
-		};
-		if (Option.isNone(token) && Object.keys(registration.headers ?? {}).length === 0) return yield* new TicketResolveError({
-			reason: "not_authorized",
-			detail: "Linear is registered but not signed in on this machine. Sign in from Settings."
-		});
-		const result = yield* callMcpTool({
-			url: registration.url,
-			headers,
-			toolName: LINEAR_GET_ISSUE_TOOL,
-			arguments: { id: identifier }
-		}).pipe(Effect.provideService(HttpClient$1.HttpClient, http), Effect.mapError((error) => error.status === 401 || error.status === 403 ? new TicketResolveError({
-			reason: "not_authorized",
-			detail: "Linear rejected p4code's sign-in. Sign in again from Settings."
-		}) : new TicketResolveError({
-			reason: "unavailable",
-			detail: error.detail
-		})));
-		const issue = readIssue(result);
+		const issue = readOne(yield* linear.call(LINEAR_GET_ISSUE_TOOL, { id: identifier }).pipe(Effect.mapError((cause) => new TicketResolveError({
+			reason: cause.reason === "failed" ? "unavailable" : cause.reason,
+			detail: cause.detail
+		}))));
 		const url = issue === void 0 ? void 0 : stringField(issue, "url");
 		const title = issue === void 0 ? void 0 : stringField(issue, "title");
 		if (issue === void 0 || url === void 0 || title === void 0) return yield* new TicketResolveError({
@@ -102821,7 +103485,7 @@ const WorkspaceLayerLive = Layer.mergeAll(layer$51, WorkspaceEntriesLayerLive, W
 const ProjectFaviconResolverLayerLive = layer$49.pipe(Layer.provide(layer$51), Layer.provide(layer$50));
 const AuthLayerLive = layer$71.pipe(Layer.provideMerge(PersistenceLayerLive), Layer.provide(layer$75));
 const ProviderRuntimeLayerLive = ProviderSessionReaperLive.pipe(Layer.provideMerge(ProviderLayerLive), Layer.provideMerge(OrchestrationLayerLive));
-const RuntimeCoreDependenciesLive = ReactorLayerLive.pipe(Layer.provideMerge(CheckpointingLayerLive), Layer.provideMerge(SourceControlProviderRegistryLayerLive), Layer.provideMerge(GitLayerLive), Layer.provideMerge(VcsLayerLive), Layer.provideMerge(ProviderRuntimeLayerLive), Layer.provideMerge(Layer.mergeAll(TerminalLayerLive, PreviewLayerLive, RoutedTaskRepositoryLive)), Layer.provideMerge(Layer.mergeAll(PersistenceLayerLive, layer$64)), Layer.provideMerge(layer$59), Layer.provideMerge(ProviderRegistryLive), Layer.provideMerge(ProviderInstanceRegistryHydrationLive), Layer.provideMerge(ProviderEventLoggersLive), Layer.provideMerge(OpenCodeRuntimeLive), Layer.provideMerge(layer$68.pipe(Layer.provide(layer$75))), Layer.provideMerge(WorkspaceLayerLive), Layer.provideMerge(ProjectFaviconResolverLayerLive), Layer.provideMerge(layer$60), Layer.provideMerge(layer$53), Layer.provideMerge(AuthLayerLive), Layer.provideMerge(Layer.mergeAll(layer$1, LinearMcpClientLive).pipe(Layer.provideMerge(Layer.mergeAll(layer$65, layer$38).pipe(Layer.provideMerge(layer$66), Layer.provideMerge(layer$67))))), Layer.provideMerge(layer$75));
+const RuntimeCoreDependenciesLive = ReactorLayerLive.pipe(Layer.provideMerge(CheckpointingLayerLive), Layer.provideMerge(SourceControlProviderRegistryLayerLive), Layer.provideMerge(GitLayerLive), Layer.provideMerge(VcsLayerLive), Layer.provideMerge(ProviderRuntimeLayerLive), Layer.provideMerge(Layer.mergeAll(TerminalLayerLive, PreviewLayerLive, RoutedTaskRepositoryLive)), Layer.provideMerge(Layer.mergeAll(PersistenceLayerLive, layer$64)), Layer.provideMerge(layer$59), Layer.provideMerge(ProviderRegistryLive), Layer.provideMerge(ProviderInstanceRegistryHydrationLive), Layer.provideMerge(ProviderEventLoggersLive), Layer.provideMerge(OpenCodeRuntimeLive), Layer.provideMerge(layer$68.pipe(Layer.provide(layer$75))), Layer.provideMerge(WorkspaceLayerLive), Layer.provideMerge(ProjectFaviconResolverLayerLive), Layer.provideMerge(layer$60), Layer.provideMerge(layer$53), Layer.provideMerge(AuthLayerLive), Layer.provideMerge(layer$1.pipe(Layer.provideMerge(LinearClientLive), Layer.provideMerge(Layer.mergeAll(LinearMcpClientLive, TrackerSecretsLive)), Layer.provideMerge(Layer.mergeAll(layer$65, layer$38).pipe(Layer.provideMerge(layer$66), Layer.provideMerge(layer$67))))), Layer.provideMerge(layer$75));
 const UsageLayerLive = layer$39.pipe(Layer.provide(layer$68.pipe(Layer.provide(layer$75))));
 const RuntimeDependenciesLive = RuntimeCoreDependenciesLive.pipe(Layer.provideMerge(UsageLayerLive), Layer.provideMerge(layer$15), Layer.provideMerge(layer$14), Layer.provideMerge(layer$13), Layer.provideMerge(layer$56), Layer.provideMerge(layer$58), Layer.provideMerge(layer$57), Layer.provide(layer$79));
 /**