@cmmd-center/forge 0.13.2 → 0.13.4

package/dist/bin.cjs

@@ -2,18 +2,18 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk-BhaIgcZK.cjs");
-const require_Schema$1 = require("./Schema-dLi7Qssy.cjs");
-const require_Path = require("./Path-Be7zSwar.cjs");
-const require_NodeTerminal = require("./NodeTerminal-5iWbO0B2.cjs");
-const require_NodeServices = require("./NodeServices-Cw6SxEbl.cjs");
-const require_HttpServer = require("./HttpServer-DGoLR-kU.cjs");
-const require_Config = require("./Config-CkEzdD9L.cjs");
-const require_Cache = require("./Cache-CWlxNDbC.cjs");
-const require_SqlError = require("./SqlError-Bt0Bcd5C.cjs");
+const require_Schema$1 = require("./Schema-CDCJ3xZo.cjs");
+const require_Path = require("./Path-CGCc_dDx.cjs");
+const require_NodeTerminal = require("./NodeTerminal-rYbifme7.cjs");
+const require_NodeServices = require("./NodeServices-Cb0rXFb2.cjs");
+const require_HttpServer = require("./HttpServer-D1gSU7NX.cjs");
+const require_Config = require("./Config-CwKCCk14.cjs");
+const require_Cache = require("./Cache-DCF22Dfk.cjs");
+const require_SqlError = require("./SqlError-CzB6p9lL.cjs");
 const require_Mime = require("./Mime-Bilnh8zE.cjs");
 const require_esm = require("./esm-BZhXwX5p.cjs");
 const require_runtimeControlAuthority = require("./runtimeControlAuthority-B3kNmYRT.cjs");
-const require_PTY = require("./PTY-BxYDiW3h.cjs");
+const require_PTY = require("./PTY-B4ZctbwQ.cjs");
 let node_child_process = require("node:child_process");
 node_child_process = require_chunk.__toESM(node_child_process);
 let node_stream = require("node:stream");
@@ -16544,7 +16544,7 @@ function makeNetServiceShape(createServer = node_net.createServer) {
 }
 //#endregion
 //#region ../../packages/shared/src/releaseInfo.generated.ts
-const FORGE_RELEASE_VERSION = "0.13.2";
+const FORGE_RELEASE_VERSION = "0.13.4";
 //#endregion
 //#region ../../packages/shared/src/hostProcess.ts
 /**
@@ -16668,6 +16668,70 @@ const CheckpointRef = makeEntityId("CheckpointRef");
 */
 const ThreadEnvMode = require_Schema$1.Literals(["local", "worktree"]);
 //#endregion
+//#region ../../packages/contracts/src/assets.ts
+/**
+* Addresses for the bytes a client cannot fetch by guessing.
+*
+* Forge already serves the bytes: attachments under `/attachments/*` and
+* project favicons at `GET /api/project-favicon?cwd=`. What it did not serve
+* was the question "what is the URL for this thing", which is the only way a
+* client that holds an attachment id or a workspace root can reach either.
+* The phone asks that question on the thread list for every project, so
+* until this existed the answer was an error the phone drew as a spinner.
+*
+* These schemas are the Forge side of `assets.*` in the vendored t3 contracts.
+* They must decode what that package encodes: same tags, same field names.
+*/
+const ASSET_PATH_MAX_LENGTH = 1024;
+const ASSET_ID_MAX_LENGTH = 256;
+const ASSET_URL_MAX_LENGTH = 4096;
+const AssetResource = require_Schema$1.Union([
+	require_Schema$1.TaggedStruct("workspace-file", {
+		threadId: ThreadId,
+		path: TrimmedNonEmptyString.check(require_Schema$1.isMaxLength(ASSET_PATH_MAX_LENGTH))
+	}),
+	require_Schema$1.TaggedStruct("attachment", { attachmentId: TrimmedNonEmptyString.check(require_Schema$1.isMaxLength(ASSET_ID_MAX_LENGTH)) }),
+	require_Schema$1.TaggedStruct("project-favicon", {
+		cwd: TrimmedNonEmptyString.check(require_Schema$1.isMaxLength(ASSET_PATH_MAX_LENGTH)),
+		path: require_Schema$1.optional(TrimmedNonEmptyString.check(require_Schema$1.isMaxLength(ASSET_PATH_MAX_LENGTH)))
+	})
+]);
+const AssetCreateUrlInput = require_Schema$1.Struct({ resource: AssetResource });
+const AssetCreateUrlResult = require_Schema$1.Struct({
+	relativeUrl: TrimmedNonEmptyString.check(require_Schema$1.isMaxLength(ASSET_URL_MAX_LENGTH)),
+	expiresAt: require_Schema$1.Number,
+	sourcePath: require_Schema$1.optional(TrimmedNonEmptyString.check(require_Schema$1.isMaxLength(ASSET_PATH_MAX_LENGTH)))
+});
+/**
+* The resource cannot be addressed by URL on this server.
+*
+* Tag and message match the vendored client's `AssetAccessError` union so the
+* phone decodes the failure rather than falling through to a generic transport
+* error. `workspace-file` is the case that lands here.
+*/
+var AssetWorkspaceResolutionError = class extends require_Schema$1.TaggedErrorClass()("AssetWorkspaceResolutionError", {
+	resource: AssetResource,
+	cause: require_Schema$1.optional(require_Schema$1.Defect)
+}) {
+	get message() {
+		return "Failed to resolve workspace.";
+	}
+};
+/** The signing key that makes an asset URL self-authenticating could not be read. */
+var AssetSigningKeyLoadError = class extends require_Schema$1.TaggedErrorClass()("AssetSigningKeyLoadError", {
+	resource: AssetResource,
+	cause: require_Schema$1.optional(require_Schema$1.Defect)
+}) {
+	get message() {
+		return "Failed to load the asset signing key.";
+	}
+};
+const AssetAccessError = require_Schema$1.Union([AssetWorkspaceResolutionError, AssetSigningKeyLoadError]);
+const AssetsRpcSchemas = { createUrl: {
+	input: AssetCreateUrlInput,
+	output: AssetCreateUrlResult
+} };
+//#endregion
 //#region ../../node_modules/.bun/effect@4.0.0-beta.51/node_modules/effect/dist/unstable/rpc/RpcMiddleware.js
 /**
 * @since 4.0.0
@@ -18200,6 +18264,7 @@ const ExecutionEnvironmentCapabilities = require_Schema$1.Struct({
 	threadPullRequestLinking: require_Schema$1.optionalKey(require_Schema$1.Boolean),
 	cloudMode: require_Schema$1.Boolean.pipe(require_Schema$1.withDecodingDefault(require_Schema$1.succeed(false))),
 	threadSettlement: require_Schema$1.optionalKey(require_Schema$1.Boolean),
+	threadTitleRegeneration: require_Schema$1.optionalKey(require_Schema$1.Boolean),
 	posthogPublicKey: require_Schema$1.NullOr(require_Schema$1.String).pipe(require_Schema$1.withDecodingDefault(require_Schema$1.succeed(null))),
 	posthogHost: require_Schema$1.NullOr(require_Schema$1.String).pipe(require_Schema$1.withDecodingDefault(require_Schema$1.succeed(null))),
 	runtime: require_Schema$1.optionalKey(ExecutionEnvironmentRuntimeCapabilities),
@@ -19228,6 +19293,51 @@ require_Schema$1.Struct({
 	headRepositoryNameWithOwner: require_Schema$1.optional(require_Schema$1.NullOr(TrimmedNonEmptyString)),
 	headRepositoryOwnerLogin: require_Schema$1.optional(require_Schema$1.NullOr(TrimmedNonEmptyString))
 });
+const SourceControlCloneProtocol = require_Schema$1.Literals([
+	"auto",
+	"ssh",
+	"https"
+]);
+const SourceControlRepositoryInfo = require_Schema$1.Struct({
+	provider: SourceControlProviderKind$1,
+	nameWithOwner: TrimmedNonEmptyString,
+	url: TrimmedNonEmptyString,
+	sshUrl: TrimmedNonEmptyString
+});
+const SourceControlRepositoryLookupInput = require_Schema$1.Struct({
+	provider: SourceControlProviderKind$1,
+	repository: TrimmedNonEmptyString,
+	cwd: require_Schema$1.optional(TrimmedNonEmptyString)
+});
+/**
+* Either name the repository (`provider` + `repository`) or paste a clone URL
+* (`remoteUrl`). Both are optional in the schema because the phone sends one
+* or the other depending on how the user got here; the server rejects a call
+* that supplies neither, and rejects a `remoteUrl` it cannot resolve to a
+* repository it is allowed to fetch a token for.
+*/
+const SourceControlCloneRepositoryInput = require_Schema$1.Struct({
+	provider: require_Schema$1.optional(SourceControlProviderKind$1),
+	repository: require_Schema$1.optional(TrimmedNonEmptyString),
+	remoteUrl: require_Schema$1.optional(TrimmedNonEmptyString),
+	destinationPath: TrimmedNonEmptyString,
+	protocol: require_Schema$1.optional(SourceControlCloneProtocol)
+});
+const SourceControlCloneRepositoryResult = require_Schema$1.Struct({
+	cwd: TrimmedNonEmptyString,
+	remoteUrl: TrimmedNonEmptyString,
+	repository: require_Schema$1.NullOr(SourceControlRepositoryInfo)
+});
+var SourceControlRepositoryError = class extends require_Schema$1.TaggedErrorClass()("SourceControlRepositoryError", {
+	provider: SourceControlProviderKind$1,
+	operation: require_Schema$1.String,
+	detail: require_Schema$1.String,
+	cause: require_Schema$1.optional(require_Schema$1.Defect)
+}) {
+	get message() {
+		return `Source control repository operation ${this.operation} failed for ${this.provider}: ${this.detail}`;
+	}
+};
 //#endregion
 //#region ../../packages/contracts/src/orchestration.ts
 const ORCHESTRATION_WS_METHODS = {
@@ -19239,7 +19349,8 @@ const ORCHESTRATION_WS_METHODS = {
 	replayEvents: "orchestration.replayEvents",
 	getArchivedShellSnapshot: "orchestration.getArchivedShellSnapshot",
 	subscribeShell: "orchestration.subscribeShell",
-	subscribeThread: "orchestration.subscribeThread"
+	subscribeThread: "orchestration.subscribeThread",
+	searchThreads: "orchestration.searchThreads"
 };
 const ProviderKind = require_Schema$1.Literals([
 	"codex",
@@ -20623,6 +20734,32 @@ const OrchestrationGetFullThreadDiffInput = require_Schema$1.Struct({
 const OrchestrationGetFullThreadDiffResult = ThreadTurnDiff;
 const OrchestrationReplayEventsInput = require_Schema$1.Struct({ fromSequenceExclusive: NonNegativeInt });
 const OrchestrationReplayEventsResult = require_Schema$1.ArraySchema(OrchestrationEvent);
+/**
+* Which side of the conversation a search hit came from. `null`
+* `messageCreatedAt` on a match means it came from the thread's own metadata
+* (its title or its branch) rather than from a message.
+*/
+const OrchestrationThreadSearchSource = require_Schema$1.Literals(["user", "assistant"]);
+/**
+* The server's SQLite client is synchronous and single-connection, so both the
+* scan input and the response size are bounded: a search must not be able to
+* monopolize the connection every keystroke.
+*/
+const OrchestrationSearchThreadsInput = require_Schema$1.Struct({
+	query: TrimmedString.check(require_Schema$1.isMinLength(2), require_Schema$1.isMaxLength(200)),
+	limit: require_Schema$1.optionalKey(require_Schema$1.Int.check(require_Schema$1.isBetween({
+		minimum: 1,
+		maximum: 50
+	})))
+});
+const OrchestrationThreadSearchMatch = require_Schema$1.Struct({
+	threadId: ThreadId,
+	projectId: ProjectId,
+	source: OrchestrationThreadSearchSource,
+	snippet: require_Schema$1.String.check(require_Schema$1.isMaxLength(240)),
+	messageCreatedAt: require_Schema$1.NullOr(IsoDateTime)
+});
+const OrchestrationSearchThreadsResult = require_Schema$1.Struct({ matches: require_Schema$1.ArraySchema(OrchestrationThreadSearchMatch) });
 const ProgressPercent = NonNegativeInt.check(require_Schema$1.isLessThanOrEqualTo(100));
 const AgentProtocolProgress = require_Schema$1.Struct({
 	kind: require_Schema$1.Literal("PROGRESS"),
@@ -20698,6 +20835,10 @@ const OrchestrationRpcSchemas = {
 	getArchivedShellSnapshot: {
 		input: require_Schema$1.Struct({}),
 		output: OrchestrationShellSnapshot
+	},
+	searchThreads: {
+		input: OrchestrationSearchThreadsInput,
+		output: OrchestrationSearchThreadsResult
 	}
 };
 var OrchestrationGetSnapshotError = class extends require_Schema$1.TaggedErrorClass()("OrchestrationGetSnapshotError", {
@@ -20720,6 +20861,10 @@ var OrchestrationReplayEventsError = class extends require_Schema$1.TaggedErrorC
 	message: TrimmedNonEmptyString,
 	cause: require_Schema$1.optional(require_Schema$1.Defect)
 }) {};
+var OrchestrationSearchThreadsError = class extends require_Schema$1.TaggedErrorClass()("OrchestrationSearchThreadsError", {
+	message: TrimmedNonEmptyString,
+	cause: require_Schema$1.optional(require_Schema$1.Defect)
+}) {};
 //#endregion
 //#region ../../packages/contracts/src/provider.ts
 const ProviderSessionStatus = require_Schema$1.Literals([
@@ -20782,6 +20927,31 @@ const ProviderRespondToUserInputInput = require_Schema$1.Struct({
 	requestId: ApprovalRequestId,
 	answers: ProviderUserInputAnswers
 });
+/**
+* Sending a thread to the people who maintain Forge.
+*
+* The vendored client's `/feedback` slash command calls this. Upstream it
+* uploads the transcript to the model provider; Forge routes it to the same
+* CMMD feedback intake the web app's feedback dialog already posts to, so one
+* report lands in one place no matter which surface filed it.
+*
+* `reason` is what the person typed after the command, and is the only part
+* of the report they wrote. The server fills in the rest.
+*/
+const ProviderUploadFeedbackInput = require_Schema$1.Struct({
+	threadId: ThreadId,
+	reason: require_Schema$1.optional(TrimmedNonEmptyString.check(require_Schema$1.isMaxLength(4e3)))
+});
+const ProviderUploadFeedbackResult = require_Schema$1.Struct({ feedbackId: TrimmedNonEmptyString });
+var ProviderUploadFeedbackError = class extends require_Schema$1.TaggedErrorClass()("ProviderUploadFeedbackError", {
+	threadId: ThreadId,
+	reason: require_Schema$1.optional(TrimmedNonEmptyString.check(require_Schema$1.isMaxLength(500))),
+	cause: require_Schema$1.optional(require_Schema$1.Defect)
+}) {
+	get message() {
+		return this.reason ?? "Feedback could not be sent. Please try again.";
+	}
+};
 const ProviderEventKind = require_Schema$1.Literals([
 	"session",
 	"notification",
@@ -21261,6 +21431,46 @@ const TaskStartedPayload = require_Schema$1.Struct({
 	description: require_Schema$1.optional(TrimmedNonEmptyStringSchema$2),
 	taskType: require_Schema$1.optional(TrimmedNonEmptyStringSchema$2)
 });
+/**
+* Watch-loop task types: Monitor-tool tasks plus background shells. A shell
+* that outlives its turn is in practice a watch loop, not delegated work.
+*/
+const MONITOR_TASK_TYPES = new Set([
+	"monitor",
+	"monitor_mcp",
+	"local_bash",
+	"shell"
+]);
+/** Task types that are neither agents nor watch loops (plan-mode bookkeeping). */
+const INERT_TASK_TYPES = new Set(["plan", "dream"]);
+/**
+* Agent-vs-background classification for a task row.
+*
+* The mobile client reads `agentKind` off the persisted activity payload and
+* treats a row without it as background, so a server that never stamps the
+* field leaves the Agents roster permanently empty however much subagent work
+* is running (FOR-36646). This is the stamp.
+*
+* A denylist, not an allowlist, and deliberately so: the agent-flavoured type
+* names drift with the SDKs (subagent, local_agent, local_workflow, and
+* whatever lands next), and an allowlist drops real subagents the day a new
+* name appears. Only the watch loops and the plan-mode bookkeeping types are
+* named here; everything else is delegated work.
+*
+* A task launched from inside a subagent (`agentId` set) is agent-internal
+* background work unless it is itself agent-flavoured, because a nested agent
+* can outlive its parent and has to stay in the roster.
+*
+* This mirrors `classifyTaskAgentKind` in the contracts the phone speaks. The
+* two packages do not import each other, so the sets are duplicated on
+* purpose; they have to agree, and the tests on both sides pin the same cases.
+*/
+function classifyTaskAgentKind(input) {
+	const { taskType, agentId } = input;
+	const nonAgentType = taskType !== void 0 && (MONITOR_TASK_TYPES.has(taskType) || INERT_TASK_TYPES.has(taskType));
+	if (agentId !== void 0 && agentId.trim().length > 0) return taskType === void 0 || nonAgentType ? "background" : "agent";
+	return nonAgentType ? "background" : "agent";
+}
 const TaskProgressPayload = require_Schema$1.Struct({
 	taskId: RuntimeTaskId,
 	description: TrimmedNonEmptyStringSchema$2,
@@ -25989,6 +26199,8 @@ const WS_METHODS = {
 	projectsListEntries: "projects.listEntries",
 	serverDiscoverSourceControl: "server.discoverSourceControl",
 	serverReportClientActivity: "server.reportClientActivity",
+	sourceControlLookupRepository: "sourceControl.lookupRepository",
+	sourceControlCloneRepository: "sourceControl.cloneRepository",
 	projectsWriteFile: "projects.writeFile",
 	projectCheckoutDeletionPreview: "projectCheckoutDeletion.preview",
 	projectCheckoutDeletionExecute: "projectCheckoutDeletion.execute",
@@ -26092,7 +26304,9 @@ const WS_METHODS = {
 	subscribeServerConfig: "subscribeServerConfig",
 	subscribeServerLifecycle: "subscribeServerLifecycle",
 	subscribeAuthAccess: "subscribeAuthAccess",
-	subscribeWorkspaceReadiness: "subscribeWorkspaceReadiness"
+	subscribeWorkspaceReadiness: "subscribeWorkspaceReadiness",
+	assetsCreateUrl: "assets.createUrl",
+	providerUploadFeedback: "provider.uploadFeedback"
 };
 const WsServerUpsertKeybindingRpc = make$30(WS_METHODS.serverUpsertKeybinding, {
 	payload: ServerUpsertKeybindingInput,
@@ -26621,6 +26835,29 @@ const WsOrchestrationGetArchivedShellSnapshotRpc = make$30(ORCHESTRATION_WS_METH
 	success: OrchestrationRpcSchemas.getArchivedShellSnapshot.output,
 	error: OrchestrationGetSnapshotError
 });
+const WsOrchestrationSearchThreadsRpc = make$30(ORCHESTRATION_WS_METHODS.searchThreads, {
+	payload: OrchestrationSearchThreadsInput,
+	success: OrchestrationRpcSchemas.searchThreads.output,
+	error: OrchestrationSearchThreadsError
+});
+/**
+* Resolve `owner/repo` to the repository the caller is allowed to clone.
+*
+* Both of these run against the same CMMD-brokered GitHub credential the web
+* add-project flow uses, so a lookup that answers is a lookup whose clone can
+* also be authorized, and a repository the caller cannot reach is a failure
+* here rather than a clone that dies half way.
+*/
+const WsSourceControlLookupRepositoryRpc = make$30(WS_METHODS.sourceControlLookupRepository, {
+	payload: SourceControlRepositoryLookupInput,
+	success: SourceControlRepositoryInfo,
+	error: SourceControlRepositoryError
+});
+const WsSourceControlCloneRepositoryRpc = make$30(WS_METHODS.sourceControlCloneRepository, {
+	payload: SourceControlCloneRepositoryInput,
+	success: SourceControlCloneRepositoryResult,
+	error: SourceControlRepositoryError
+});
 const WsOrchestrationSubscribeShellRpc = make$30(ORCHESTRATION_WS_METHODS.subscribeShell, {
 	payload: OrchestrationRpcSchemas.subscribeShell.input,
 	success: OrchestrationRpcSchemas.subscribeShell.output,
@@ -26701,7 +26938,15 @@ const WsRpcGroup = make$29(WsServerGetConfigRpc, WsServerRefreshProvidersRpc, Ws
 	payload: UsageSummaryInput,
 	success: UsageSummary,
 	error: UsageReadError
-}), WsPullRequestsListRpc, WsPullRequestsListStatsRpc, WsPullRequestsDetailRpc, WsPullRequestsActivityRpc, WsPullRequestsThreadCommentsRpc, WsPullRequestsDiffFileContentsRpc, WsPullRequestsRunActionRpc, WsPullRequestsUpdateRpc, WsPullRequestsCommentRpc, WsPullRequestsUpdateCommentRpc, WsPullRequestsSubmitReviewRpc, WsPullRequestsReplyToThreadRpc, WsPullRequestsSetThreadResolutionRpc, WsPullRequestsSetReactionRpc, WsPullRequestsInvalidateRpc, WsPullRequestsReviewerCandidatesRpc, WsPullRequestsRequestReviewersRpc, WsProjectsSearchEntriesRpc, WsProjectsWriteFileRpc, WsProjectCheckoutDeletionPreviewRpc, WsProjectCheckoutDeletionExecuteRpc, WsCodeGraphSummaryRpc, WsCodeGraphNeighborhoodRpc, WsCodeGraphSearchRpc, WsWorkspaceReadFileRpc, WsWorkspaceBeginWriteFileRpc, WsWorkspaceWriteFileChunkRpc, WsWorkspaceCommitWriteFileRpc, WsWorkspaceCancelWriteFileRpc, WsShellOpenInEditorRpc, WsSubscribeGitStatusRpc, WsGitPullRpc, WsGitRefreshStatusRpc, WsGitRunStackedActionRpc, WsGitResolvePullRequestRpc, WsGitPreparePullRequestThreadRpc, WsGitListBranchesRpc, WsVcsListRefsRpc, WsVcsRefreshStatusRpc, WsSubscribeVcsStatusRpc, WsVcsPullRpc, WsVcsCreateWorktreeRpc, WsVcsRemoveWorktreeRpc, WsVcsCreateRefRpc, WsVcsSwitchRefRpc, WsVcsInitRpc, WsGitCreateWorktreeRpc, WsGitRemoveWorktreeRpc, WsGitCreateBranchRpc, WsGitCheckoutRpc, WsGitInitRpc, WsFilesystemBrowseRpc, WsProjectsReadFileRpc, WsReviewGetDiffPreviewRpc, WsCloudListRuntimesRpc, WsTerminalOpenRpc, WsTerminalAttachRpc, WsTerminalWriteRpc, WsTerminalResizeRpc, WsTerminalSignalRpc, WsTerminalClearRpc, WsTerminalRestartRpc, WsTerminalCloseRpc, WsBrowserOpenSessionRpc, WsBrowserListSessionsRpc, WsBrowserCloseSessionRpc, WsBrowserGetSessionRpc, WsBrowserCommandRpc, WsBrowserClearBrowsingDataRpc, WsBrowserAttachDisplayRpc, WsBrowserAddDisplayIceCandidateRpc, WsComputerInputRpc, WsDevTunnelRegisterRpc, WsDevTunnelUnregisterRpc, WsDevTunnelListRpc, WsThreadDevRuntimeGetRpc, WsThreadDevRuntimeAllocatePortRpc, WsThreadDevRuntimeReleaseRpc, WsWorkspaceEnvironmentPreflightRpc, WsWorkspaceEnsureScratchRpc, WsSubscribeTerminalEventsRpc, WsSubscribeTerminalMetadataRpc, WsProjectsListEntriesRpc, WsServerDiscoverSourceControlRpc, WsServerReportClientActivityRpc, WsSubscribeBrowserEventsRpc, WsSubscribeServerConfigRpc, WsSubscribeServerLifecycleRpc, WsSubscribeAuthAccessRpc, WsSubscribeWorkspaceReadinessRpc, WsOrchestrationDispatchCommandRpc, WsOrchestrationGetTurnDiffRpc, WsOrchestrationGetFullThreadDiffRpc, WsOrchestrationStreamTurnDiffRpc, WsOrchestrationStreamFullThreadDiffRpc, WsOrchestrationReplayEventsRpc, WsOrchestrationGetArchivedShellSnapshotRpc, WsOrchestrationSubscribeShellRpc, WsOrchestrationSubscribeThreadRpc);
+}), WsPullRequestsListRpc, WsPullRequestsListStatsRpc, WsPullRequestsDetailRpc, WsPullRequestsActivityRpc, WsPullRequestsThreadCommentsRpc, WsPullRequestsDiffFileContentsRpc, WsPullRequestsRunActionRpc, WsPullRequestsUpdateRpc, WsPullRequestsCommentRpc, WsPullRequestsUpdateCommentRpc, WsPullRequestsSubmitReviewRpc, WsPullRequestsReplyToThreadRpc, WsPullRequestsSetThreadResolutionRpc, WsPullRequestsSetReactionRpc, WsPullRequestsInvalidateRpc, WsPullRequestsReviewerCandidatesRpc, WsPullRequestsRequestReviewersRpc, WsProjectsSearchEntriesRpc, WsProjectsWriteFileRpc, WsProjectCheckoutDeletionPreviewRpc, WsProjectCheckoutDeletionExecuteRpc, WsCodeGraphSummaryRpc, WsCodeGraphNeighborhoodRpc, WsCodeGraphSearchRpc, WsWorkspaceReadFileRpc, WsWorkspaceBeginWriteFileRpc, WsWorkspaceWriteFileChunkRpc, WsWorkspaceCommitWriteFileRpc, WsWorkspaceCancelWriteFileRpc, WsShellOpenInEditorRpc, WsSubscribeGitStatusRpc, WsGitPullRpc, WsGitRefreshStatusRpc, WsGitRunStackedActionRpc, WsGitResolvePullRequestRpc, WsGitPreparePullRequestThreadRpc, WsGitListBranchesRpc, WsVcsListRefsRpc, WsVcsRefreshStatusRpc, WsSubscribeVcsStatusRpc, WsVcsPullRpc, WsVcsCreateWorktreeRpc, WsVcsRemoveWorktreeRpc, WsVcsCreateRefRpc, WsVcsSwitchRefRpc, WsVcsInitRpc, WsGitCreateWorktreeRpc, WsGitRemoveWorktreeRpc, WsGitCreateBranchRpc, WsGitCheckoutRpc, WsGitInitRpc, WsFilesystemBrowseRpc, WsProjectsReadFileRpc, WsReviewGetDiffPreviewRpc, WsCloudListRuntimesRpc, WsTerminalOpenRpc, WsTerminalAttachRpc, WsTerminalWriteRpc, WsTerminalResizeRpc, WsTerminalSignalRpc, WsTerminalClearRpc, WsTerminalRestartRpc, WsTerminalCloseRpc, WsBrowserOpenSessionRpc, WsBrowserListSessionsRpc, WsBrowserCloseSessionRpc, WsBrowserGetSessionRpc, WsBrowserCommandRpc, WsBrowserClearBrowsingDataRpc, WsBrowserAttachDisplayRpc, WsBrowserAddDisplayIceCandidateRpc, WsComputerInputRpc, WsDevTunnelRegisterRpc, WsDevTunnelUnregisterRpc, WsDevTunnelListRpc, WsThreadDevRuntimeGetRpc, WsThreadDevRuntimeAllocatePortRpc, WsThreadDevRuntimeReleaseRpc, WsWorkspaceEnvironmentPreflightRpc, WsWorkspaceEnsureScratchRpc, WsSubscribeTerminalEventsRpc, WsSubscribeTerminalMetadataRpc, WsProjectsListEntriesRpc, WsServerDiscoverSourceControlRpc, WsServerReportClientActivityRpc, WsSubscribeBrowserEventsRpc, WsSubscribeServerConfigRpc, WsSubscribeServerLifecycleRpc, WsSubscribeAuthAccessRpc, WsSubscribeWorkspaceReadinessRpc, WsOrchestrationDispatchCommandRpc, WsOrchestrationGetTurnDiffRpc, WsOrchestrationGetFullThreadDiffRpc, WsOrchestrationStreamTurnDiffRpc, WsOrchestrationStreamFullThreadDiffRpc, WsOrchestrationReplayEventsRpc, WsOrchestrationGetArchivedShellSnapshotRpc, WsOrchestrationSubscribeShellRpc, WsOrchestrationSubscribeThreadRpc, make$30(WS_METHODS.assetsCreateUrl, {
+	payload: AssetsRpcSchemas.createUrl.input,
+	success: AssetsRpcSchemas.createUrl.output,
+	error: AssetAccessError
+}), make$30(WS_METHODS.providerUploadFeedback, {
+	payload: ProviderUploadFeedbackInput,
+	success: ProviderUploadFeedbackResult,
+	error: ProviderUploadFeedbackError
+}), WsOrchestrationSearchThreadsRpc, WsSourceControlLookupRepositoryRpc, WsSourceControlCloneRepositoryRpc);
 const RelayWsRpcGroup = WsRpcGroup.middleware(RelayAuthorizationMiddleware).middleware(RelayDeliveryMiddleware);
 /**
 * The direct-WebSocket mount of the same group, with per-method scope
@@ -31841,6 +32086,31 @@ const RELAY_METHOD_POLICY_BASES = [
 		method: ORCHESTRATION_WS_METHODS.subscribeThread,
 		requiredScope: "thread.read",
 		deliveryClass: "subscription"
+	},
+	{
+		method: WS_METHODS.assetsCreateUrl,
+		requiredScope: "thread.read",
+		deliveryClass: "read"
+	},
+	{
+		method: ORCHESTRATION_WS_METHODS.searchThreads,
+		requiredScope: "thread.read",
+		deliveryClass: "read"
+	},
+	{
+		method: WS_METHODS.providerUploadFeedback,
+		requiredScope: "thread.read",
+		deliveryClass: "create-command"
+	},
+	{
+		method: WS_METHODS.sourceControlLookupRepository,
+		requiredScope: "git.read",
+		deliveryClass: "read"
+	},
+	{
+		method: WS_METHODS.sourceControlCloneRepository,
+		requiredScope: "project.write",
+		deliveryClass: "idempotent-command"
 	}
 ];
 const FRAME_JOURNALED_METHODS = new Set([
@@ -34008,7 +34278,7 @@ function isRejectedCredential(cause) {
 //#region src/connect/hiddenInput.ts
 /** Ctrl-C arrives as this byte on a raw TTY rather than as a signal. */
 const END_OF_TEXT = "";
-function firstLine(value) {
+function firstLine$1(value) {
 	const index = value.indexOf("\n");
 	const line = index === -1 ? value : value.slice(0, index);
 	return line.endsWith("\r") ? line.slice(0, -1) : line;
@@ -34033,7 +34303,7 @@ function readHiddenLine(input) {
 			settled = true;
 			detach();
 			input.output.write("\n");
-			resolve(firstLine(value));
+			resolve(firstLine$1(value));
 		};
 		const onData = (chunk) => {
 			buffer += chunk.toString();
@@ -35465,7 +35735,7 @@ function stringify(value, fallback = "[unserializable]") {
 		return typeof fallback === "function" ? fallback(value) : fallback;
 	}
 }
-function truncate$1(str, max = 0) {
+function truncate$2(str, max = 0) {
 	if (typeof str !== "string" || max === 0) return str;
 	return str.length <= max ? str : `${str.slice(0, max)}...`;
 }
@@ -36072,7 +36342,7 @@ var Scope = class Scope {
 		const mergedBreadcrumb = {
 			timestamp: dateTimestampInSeconds(),
 			...breadcrumb,
-			message: breadcrumb.message ? truncate$1(breadcrumb.message, 2048) : breadcrumb.message
+			message: breadcrumb.message ? truncate$2(breadcrumb.message, 2048) : breadcrumb.message
 		};
 		this._breadcrumbs.push(mergedBreadcrumb);
 		if (this._breadcrumbs.length > maxCrumbs) {
@@ -38730,9 +39000,9 @@ function applyClientOptions(event, options) {
 	if (!event.release && release) event.release = release;
 	if (!event.dist && dist) event.dist = dist;
 	const request = event.request;
-	if (request?.url && maxValueLength) request.url = truncate$1(request.url, maxValueLength);
+	if (request?.url && maxValueLength) request.url = truncate$2(request.url, maxValueLength);
 	if (maxValueLength) event.exception?.values?.forEach((exception) => {
-		if (exception.value) exception.value = truncate$1(exception.value, maxValueLength);
+		if (exception.value) exception.value = truncate$2(exception.value, maxValueLength);
 	});
 }
 function applyDebugIds(event, stackParser) {
@@ -62349,7 +62619,7 @@ const cacheResponseHook = (span, redisCommand, cmdArgs, response) => {
 		[SEMANTIC_ATTRIBUTE_CACHE_KEY]: safeKey
 	});
 	const spanDescription = safeKey.join(", ");
-	span.updateName(_redisOptions.maxCacheKeyLength ? truncate$1(spanDescription, _redisOptions.maxCacheKeyLength) : spanDescription);
+	span.updateName(_redisOptions.maxCacheKeyLength ? truncate$2(spanDescription, _redisOptions.maxCacheKeyLength) : spanDescription);
 };
 //#endregion
 //#region ../../node_modules/.bun/@sentry+node@10.70.0+cfd4f484ffd29da6/node_modules/@sentry/node/build/esm/integrations/tracing/redis/vendored/semconv.js
@@ -65864,7 +66134,7 @@ function normalizeNumberish(value) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.13.2";
+var version$1 = "0.13.4";
 //#endregion
 //#region src/sentry.ts
 const SERVER_APP_NAME = "forge-server";
@@ -69400,6 +69670,103 @@ var BrowserTraceCollector = class extends require_Schema$1.Service()("forge/obse
 */
 var ProjectFaviconResolver = class extends require_Schema$1.Service()("forge/project/Services/ProjectFaviconResolver") {};
 //#endregion
+//#region src/auth/Services/ServerSecretStore.ts
+var SecretStoreError = class extends require_Schema$1.TaggedError("SecretStoreError") {};
+var ServerSecretStore = class extends require_Schema$1.Service()("forge/auth/Services/ServerSecretStore") {};
+//#endregion
+//#region src/auth/assetUrlToken.ts
+/**
+* A credential an image tag can carry.
+*
+* `/attachments/*` and `GET /api/project-favicon` both require an authenticated
+* request, and the clients that render those bytes hand a bare URL to an image
+* loader that sends no cookie and no Authorization header. Web gets away with
+* it because the browser attaches the session cookie itself. The phone holds a
+* bearer token it has no way to attach, so every asset it fetched would 401.
+*
+* So the URL carries its own proof. The token is signed with the same server
+* signing key as the session and WebSocket credentials, and it is deliberately
+* weaker than either of those: it names one resource, and presenting it grants
+* that resource and nothing else. A leaked favicon URL is a leaked favicon.
+*/
+const ASSET_TOKEN_KIND = "asset";
+const ASSET_URL_TOKEN_QUERY_PARAM = "assetToken";
+/**
+* An hour, against a client that re-asks every thirty minutes.
+*
+* The vendored client refreshes asset URLs on a thirty-minute interval, so a
+* shorter life would expire URLs the client still believes are good, and the
+* failure would show up as an image that worked and then stopped.
+*/
+const DEFAULT_ASSET_URL_TOKEN_TTL = require_Schema$1.hours(1);
+const SIGNING_SECRET_NAME$1 = "server-signing-key";
+const AssetTokenClaims = require_Schema$1.Struct({
+	v: require_Schema$1.Literal(1),
+	kind: require_Schema$1.Literal(ASSET_TOKEN_KIND),
+	sid: require_Schema$1.String,
+	res: require_Schema$1.String,
+	iat: require_Schema$1.Number,
+	exp: require_Schema$1.Number
+});
+const decodeAssetTokenClaims = require_Schema$1.decodeUnknownEffect(require_Schema$1.fromJsonString(AssetTokenClaims));
+/**
+* The canonical name of one addressable asset.
+*
+* Both the mint and the check compute this from their own side: the RPC from
+* the resource it was asked about, the route from the request it received. They
+* have to agree exactly, which is the point. A token minted for one attachment
+* cannot be replayed against another, or against a favicon.
+*
+* The key is built from the address, not the logical id, because the address is
+* what both sides actually hold. The attachments route reads its id straight
+* out of the URL path without percent-decoding, so keying on the decoded id
+* would let the two sides disagree about an id that encodes to something else.
+*/
+function assetResourceKey(resource) {
+	return resource.kind === "attachment" ? `attachment:${resource.urlPathSegment}` : `project-favicon:${resource.cwd}`;
+}
+const resolveSigningSecret = require_Schema$1.gen(function* () {
+	const serverConfig = yield* ServerConfig;
+	const secretStore = yield* ServerSecretStore;
+	return resolveConfiguredSigningKey(serverConfig.sessionSigningKey) ?? (yield* secretStore.getOrCreateRandom(SIGNING_SECRET_NAME$1, 32));
+});
+const issueAssetUrlToken = (input) => require_Schema$1.gen(function* () {
+	const secret = yield* resolveSigningSecret;
+	const issuedAt = yield* require_Schema$1.now;
+	const expiresAt = require_Schema$1.add(issuedAt, { milliseconds: require_Schema$1.toMillis(input.ttl ?? DEFAULT_ASSET_URL_TOKEN_TTL) });
+	const claims = {
+		v: 1,
+		kind: ASSET_TOKEN_KIND,
+		sid: input.sessionId,
+		res: input.resourceKey,
+		iat: issuedAt.epochMilliseconds,
+		exp: expiresAt.epochMilliseconds
+	};
+	const encodedPayload = base64UrlEncode(JSON.stringify(claims));
+	return {
+		token: `${encodedPayload}.${signPayload(encodedPayload, secret)}`,
+		expiresAt: expiresAt.epochMilliseconds
+	};
+});
+/**
+* Whether this token opens this resource, right now.
+*
+* Returns a boolean rather than failing, because every negative answer means
+* the same thing to the caller: fall through to ordinary request
+* authentication. A malformed token from a stale client should behave like no
+* token at all, not like a different error.
+*/
+const verifyAssetUrlToken = (input) => require_Schema$1.gen(function* () {
+	const [encodedPayload, signature] = input.token.split(".");
+	if (!encodedPayload || !signature) return false;
+	if (!timingSafeEqualBase64Url(signature, signPayload(encodedPayload, yield* resolveSigningSecret))) return false;
+	const claims = yield* decodeAssetTokenClaims(base64UrlDecodeUtf8(encodedPayload)).pipe(require_Schema$1.orElseSucceed(() => null));
+	if (!claims) return false;
+	if (claims.res !== input.resourceKey) return false;
+	const now = yield* require_Schema$1.currentTimeMillis;
+	return claims.exp > now;
+}).pipe(require_Schema$1.orElseSucceed(() => false));
+//#endregion
 //#region src/environment/Services/ServerEnvironment.ts
 var ServerEnvironment = class extends require_Schema$1.Service()("forge/environment/Services/ServerEnvironment") {};
 //#endregion
@@ -69674,6 +70041,28 @@ const requireAuthenticatedRequest$1 = require_Schema$1.gen(function* () {
 	const request = yield* require_HttpServer.HttpServerRequest;
 	yield* (yield* ServerAuth).authenticateHttpRequest(request);
 });
+/**
+* Authenticate a request for asset bytes.
+*
+* Ordinary request authentication first, so the web app's cookie keeps working
+* exactly as it did and nothing about these routes changes for it. An asset
+* token is the fallback, for the clients that render these bytes through an
+* image loader with no way to attach a credential. See `auth/assetUrlToken.ts`
+* for why the token is scoped to one resource.
+*/
+const requireAssetAccess = (resourceKey) => require_Schema$1.gen(function* () {
+	const request = yield* require_HttpServer.HttpServerRequest;
+	const serverAuth = yield* ServerAuth;
+	const url = require_HttpServer.toURL(request);
+	const token = require_Schema$1.isSome(url) ? url.value.searchParams.get(ASSET_URL_TOKEN_QUERY_PARAM) : null;
+	if (token && token.trim().length > 0) {
+		if (yield* verifyAssetUrlToken({
+			token,
+			resourceKey
+		})) return;
+	}
+	yield* serverAuth.authenticateHttpRequest(request);
+});
 const serverEnvironmentRouteLayer = add$1("GET", "/.well-known/forge/environment", require_Schema$1.gen(function* () {
 	const descriptor = yield* require_Schema$1.service(ServerEnvironment).pipe(require_Schema$1.flatMap((serverEnvironment) => serverEnvironment.getDescriptor));
 	return require_HttpServer.jsonUnsafe(descriptor, { status: 200 });
@@ -69743,13 +70132,16 @@ const otlpTracesProxyRouteLayer = add$1("POST", OTLP_TRACES_PROXY_PATH, require_
 	captureServerError(cause, { route: "/api/observability/v1/traces" });
 }).pipe(require_Schema$1.andThen(() => require_Schema$1.logError("otlp-traces unhandled cause", { cause }))))));
 const attachmentsRouteLayer = add$1("GET", `${ATTACHMENTS_ROUTE_PREFIX}/*`, require_Schema$1.gen(function* () {
-	yield* requireAuthenticatedRequest$1;
 	const request = yield* require_HttpServer.HttpServerRequest;
 	const url = require_HttpServer.toURL(request);
 	if (require_Schema$1.isNone(url)) return require_HttpServer.text("Bad Request", { status: 400 });
 	const config = yield* ServerConfig;
 	const normalizedRelativePath = normalizeAttachmentRelativePath(url.value.pathname.slice(12));
 	if (!normalizedRelativePath) return require_HttpServer.text("Invalid attachment path", { status: 400 });
+	yield* requireAssetAccess(assetResourceKey({
+		kind: "attachment",
+		urlPathSegment: normalizedRelativePath
+	}));
 	const isIdLookup = !normalizedRelativePath.includes("/") && !normalizedRelativePath.includes(".");
 	const filePath = isIdLookup ? resolveAttachmentPathById({
 		attachmentsDir: config.attachmentsDir,
@@ -69768,11 +70160,14 @@ const attachmentsRouteLayer = add$1("GET", `${ATTACHMENTS_ROUTE_PREFIX}/*`, requ
 }).pipe(require_Schema$1.catchTag("AuthError", respondToAuthError)));
 const projectFaviconRouteLayer = add$1("GET", "/api/project-favicon", require_Schema$1.gen(function* () {
 	const request = yield* require_HttpServer.HttpServerRequest;
-	yield* (yield* ServerAuth).authenticateHttpRequest(request);
 	const url = require_HttpServer.toURL(request);
 	if (require_Schema$1.isNone(url)) return require_HttpServer.text("Bad Request", { status: 400 });
 	const projectCwd = url.value.searchParams.get("cwd");
 	if (!projectCwd) return require_HttpServer.text("Missing cwd parameter", { status: 400 });
+	yield* requireAssetAccess(assetResourceKey({
+		kind: "project-favicon",
+		cwd: projectCwd
+	}));
 	const faviconFilePath = yield* (yield* ProjectFaviconResolver).resolvePath(projectCwd);
 	if (!faviconFilePath) return require_HttpServer.empty({
 		status: 204,
@@ -77504,6 +77899,195 @@ require_Schema$1.succeed$1(TraceDiagnostics, TraceDiagnostics.of({ read: (option
 	}
 })) }));
 //#endregion
+//#region src/assets/createAssetUrl.ts
+const PROJECT_FAVICON_ROUTE = "/api/project-favicon";
+/**
+* Turn a resource into an address a client can fetch.
+*
+* Nothing new is served here. `/attachments/*` and `GET /api/project-favicon`
+* already return these bytes; what did not exist was the step in between, and
+* without it a client holding an attachment id or a workspace root has no way
+* to name the URL. The vendored mobile client asks this for every project on
+* its thread list, so the gap was not an edge case, it was the most visited
+* screen.
+*
+* The URL is relative so it resolves against whichever base the client is
+* already talking to, and it carries a token because the clients that render
+* these bytes hand the URL to an image loader that attaches no credential of
+* its own. See `auth/assetUrlToken.ts`.
+*/
+const createAssetUrl = (sessionId, resource) => require_Schema$1.gen(function* () {
+	if (resource._tag === "workspace-file") return yield* new AssetWorkspaceResolutionError({
+		resource,
+		cause: "Workspace files are read over projects.readFile, not by URL."
+	});
+	const address = resolveAddress(resource);
+	const issued = yield* issueAssetUrlToken({
+		sessionId,
+		resourceKey: address.resourceKey
+	}).pipe(require_Schema$1.mapError((cause) => new AssetSigningKeyLoadError({
+		resource,
+		cause
+	})));
+	return {
+		relativeUrl: `${address.path}?${address.query}assetToken=${encodeURIComponent(issued.token)}`,
+		expiresAt: issued.expiresAt,
+		...resource._tag === "project-favicon" && resource.path ? { sourcePath: resource.path } : {}
+	};
+});
+function resolveAddress(resource) {
+	if (resource._tag === "attachment") {
+		const urlPathSegment = encodeURIComponent(resource.attachmentId);
+		return {
+			resourceKey: assetResourceKey({
+				kind: "attachment",
+				urlPathSegment
+			}),
+			path: `${ATTACHMENTS_ROUTE_PREFIX}/${urlPathSegment}`,
+			query: ""
+		};
+	}
+	return {
+		resourceKey: assetResourceKey({
+			kind: "project-favicon",
+			cwd: resource.cwd
+		}),
+		path: PROJECT_FAVICON_ROUTE,
+		query: `cwd=${encodeURIComponent(resource.cwd)}&`
+	};
+}
+//#endregion
+//#region src/cmmd/submitFeedback.ts
+/** The intake the web app's feedback dialog already posts to, reached directly. */
+const CMMD_FEEDBACK_PATH = "/api/forge/context/feedback";
+/**
+* The intake answers with the task it created.
+*
+* Web reaches it through the proxy registry, which unwraps `data` before the
+* caller sees it; this calls the gateway directly and does not, so both shapes
+* are read here rather than pinning the one that happens to arrive today.
+*/
+function readFeedbackId(response) {
+	if (!response || typeof response !== "object") return null;
+	const record = response;
+	const envelope = record["data"];
+	const id = (envelope && typeof envelope === "object" ? envelope : record)["id"];
+	if (typeof id === "number") return String(id);
+	if (typeof id === "string" && id.trim().length > 0) return id.trim();
+	return null;
+}
+/**
+* File feedback against the caller's own CMMD account.
+*
+* The session's CMMD JWT is what scopes it. A server with no CMMD connection
+* has nowhere to send feedback and says so in a sentence, because the caller
+* draws this text straight into the thread the person is looking at.
+*/
+function submitCmmdFeedbackForSession(input) {
+	return require_Schema$1.gen(function* () {
+		const jwt = yield* resolveCmmdJwtForSession({
+			sessionId: input.sessionId,
+			...input.subject === void 0 ? {} : { subject: input.subject },
+			logPrefix: "cmmd-feedback"
+		}).pipe(require_Schema$1.orElseSucceed(() => null));
+		if (!jwt) return {
+			ok: false,
+			reason: "This server is not connected to CMMD, so there is nowhere to send feedback."
+		};
+		const body = {
+			type: "bug",
+			title: input.title,
+			source: "forge",
+			priority: "medium",
+			...input.description ? { description: input.description } : {},
+			...input.senderName ? { senderName: input.senderName } : {}
+		};
+		const response = yield* require_Schema$1.tryPromise(() => cmmdGateway.request({
+			method: "POST",
+			jwt,
+			path: CMMD_FEEDBACK_PATH,
+			body
+		})).pipe(require_Schema$1.orElseSucceed(() => null));
+		if (response === null) return {
+			ok: false,
+			reason: "The feedback service did not accept the report. Please try again."
+		};
+		const feedbackId = readFeedbackId(response);
+		if (feedbackId === null) return {
+			ok: false,
+			reason: "The feedback service answered without recording a report."
+		};
+		return {
+			ok: true,
+			feedbackId
+		};
+	});
+}
+//#endregion
+//#region src/provider/threadFeedback.ts
+const FEEDBACK_TITLE_MAX_CHARS = 120;
+function firstLine(text) {
+	return text.split("\n", 1)[0]?.trim() ?? "";
+}
+function truncate$1(text, max) {
+	return text.length <= max ? text : `${text.slice(0, max - 1).trimEnd()}…`;
+}
+/**
+* A title someone triaging the intake can act on.
+*
+* What the person typed after `/feedback` first, because it is the only part
+* they wrote. The thread's title is the fallback, and a bare thread id is the
+* last resort, since a queue of "Forge feedback" rows tells a triager nothing.
+*/
+function feedbackTitle(input) {
+	const reason = input.reason ? firstLine(input.reason) : "";
+	if (reason.length > 0) return truncate$1(reason, FEEDBACK_TITLE_MAX_CHARS);
+	const threadTitle = input.threadTitle?.trim() ?? "";
+	if (threadTitle.length > 0) return truncate$1(`Forge feedback: ${threadTitle}`, FEEDBACK_TITLE_MAX_CHARS);
+	return truncate$1(`Forge feedback: thread ${input.threadId}`, FEEDBACK_TITLE_MAX_CHARS);
+}
+/** The body, which always names the thread so the report can be traced back to it. */
+function feedbackDescription(input) {
+	const lines = [`Filed from Forge thread \`${input.threadId}\`.`];
+	if (input.threadTitle?.trim()) lines.push(`Thread title: ${input.threadTitle.trim()}`);
+	if (input.reason?.trim()) lines.push("", input.reason.trim());
+	return lines.join("\n");
+}
+/**
+* `/feedback`, served.
+*
+* The vendored client declared this method and called it; Forge answered
+* nothing, so the slash command printed the transport's own "unknown request
+* tag" string into the thread. Routing it to the CMMD intake the web feedback
+* dialog already uses means one report format and one destination, whichever
+* surface it came from.
+*
+* Every failure carries a sentence rather than a cause, because the client
+* draws `message` straight into the thread as an assistant reply.
+*/
+const uploadThreadFeedback = (orchestrationEngine, sessionId, subject, input) => require_Schema$1.gen(function* () {
+	const threadTitle = (yield* orchestrationEngine.getReadModel().pipe(require_Schema$1.orElseSucceed(() => null)))?.threads.find((thread) => thread.id === input.threadId)?.title;
+	const outcome = yield* submitCmmdFeedbackForSession({
+		sessionId,
+		...subject === void 0 ? {} : { subject },
+		title: feedbackTitle({
+			...input,
+			threadId: input.threadId,
+			...threadTitle ? { threadTitle } : {}
+		}),
+		description: feedbackDescription({
+			...input,
+			threadId: input.threadId,
+			...threadTitle ? { threadTitle } : {}
+		})
+	});
+	if (!outcome.ok) return yield* new ProviderUploadFeedbackError({
+		threadId: input.threadId,
+		reason: outcome.reason
+	});
+	return { feedbackId: outcome.feedbackId };
+});
+//#endregion
 //#region src/cloudRuntime/listCloudRuntimes.ts
 /**
 * List the caller's Forge Cloud runtimes, through CMMD, as the caller.
@@ -87559,95 +88143,278 @@ function resolveGitHubCloneDir(baseDir, repoFullName, targetDir) {
 	const repoName = repoFullName.split("/")[1] ?? repoFullName;
 	return targetDir ?? (0, node_path.join)(baseDir, "Projects", repoName);
 }
-const githubCloneRouteLayer = add$1("POST", "/.well-known/forge/github/clone", require_Schema$1.gen(function* () {
-	const request = yield* require_HttpServer.HttpServerRequest;
-	const session = yield* (yield* ServerAuth).authenticateHttpRequest(request);
-	const config = yield* ServerConfig;
-	if (session.method === "proxy-asserted") {
-		const forwardedJwt = normalizeForwardedCmmdJwt(request.headers);
-		if (forwardedJwt !== void 0) yield* setCommandJwtForSession(session.sessionId, forwardedJwt).pipe(require_Schema$1.ignore({ log: true }));
-	}
-	const runtimeGrantAuth = resolveRuntimeGitHubGrantAuth(config, request.headers);
-	const jwt = runtimeGrantAuth ? null : yield* resolveJwt(session.sessionId, session.subject);
-	if (!runtimeGrantAuth && !jwt) return json$6({ error: "CMMD not connected" }, 401);
-	const rawBody = yield* request.json;
-	const parsed = require_Schema$1.decodeUnknownExit(CloneBodySchema)(rawBody);
-	if (parsed._tag === "Failure") return json$6({ error: "repo_full_name is required" }, 400);
-	const { repo_full_name, target_dir } = parsed.value;
-	let token = yield* fetchInstallationTokenForAuth(runtimeGrantAuth ?? {
-		kind: "cmmd-jwt",
-		jwt
-	}, repo_full_name);
-	if (!runtimeGrantAuth && !token.ok && shouldRetryWithRefreshedCmmdJwt(token.status)) {
-		const refreshedJwt = yield* resolveJwt(session.sessionId, session.subject, true);
-		if (refreshedJwt && refreshedJwt !== jwt) token = yield* fetchInstallationTokenForAuth({
+/**
+* The public clone URLs for a repository.
+*
+* Never derived from an authenticated remote: `buildAuthenticatedRemoteUrl`
+* embeds an installation token in the URL, and a token that reaches a client is
+* a token that reaches wherever the client writes it down.
+*/
+function describeGitHubRepository(nameWithOwner) {
+	return {
+		nameWithOwner,
+		url: `https://github.com/${nameWithOwner}`,
+		sshUrl: `git@github.com:${nameWithOwner}.git`
+	};
+}
+/**
+* Resolve `owner/repo` against the repositories CMMD says this caller may use.
+*
+* This asks the same brokered listing the web repository picker is populated
+* from, rather than github.com directly, so "found" here means the same thing
+* it means everywhere else in Forge: CMMD will vend this caller a token for it.
+* A repository that exists but that the caller cannot reach is a 404, which is
+* the answer they can act on.
+*/
+function lookupGitHubRepositoryForSession(input) {
+	return require_Schema$1.gen(function* () {
+		const requested = input.repository.trim().replace(/^\/+|\/+$/g, "");
+		if (!/^[^/\s]+\/[^/\s]+$/.test(requested)) return {
+			status: 400,
+			repository: null,
+			error: "Enter a repository as owner/name."
+		};
+		const jwt = input.runtimeGrantAuth ? null : yield* resolveJwt(input.sessionId, input.subject);
+		if (!input.runtimeGrantAuth && !jwt) return {
+			status: 401,
+			repository: null,
+			error: "CMMD not connected"
+		};
+		const auth = input.runtimeGrantAuth ?? {
 			kind: "cmmd-jwt",
-			jwt: refreshedJwt
-		}, repo_full_name);
-	}
-	if (!token.ok) return json$6(gitHubTokenFailureBody(token.status, token.error), token.status);
-	const gitToken = token.token;
-	const cloneDir = resolveGitHubCloneDir(config.baseDir, repo_full_name, target_dir);
-	yield* require_Schema$1.promise(() => (0, node_fs_promises.mkdir)((0, node_path.join)(cloneDir, ".."), { recursive: true }).catch(() => void 0));
-	if ((0, node_fs.existsSync)(cloneDir)) {
-		const workTree = yield* require_Schema$1.promise(() => runProcess("git", [
+			jwt
+		};
+		const searchTerm = requested.split("/")[1] ?? requested;
+		let result = yield* require_Schema$1.promise(() => fetchGitHubReposForAuth(auth, {
+			search: searchTerm,
+			organizationId: input.organizationId ?? ""
+		}));
+		if (!input.runtimeGrantAuth && shouldRetryWithRefreshedCmmdJwt(result.status)) {
+			const refreshedJwt = yield* resolveJwt(input.sessionId, input.subject, true);
+			if (refreshedJwt && refreshedJwt !== jwt) result = yield* require_Schema$1.promise(() => fetchGitHubReposForAuth({
+				kind: "cmmd-jwt",
+				jwt: refreshedJwt
+			}, {
+				search: searchTerm,
+				organizationId: input.organizationId ?? ""
+			}));
+		}
+		if (result.status !== 200) {
+			const body = result.body;
+			return {
+				status: result.status,
+				repository: null,
+				error: typeof body.error === "string" ? body.error : "GitHub repositories are unavailable."
+			};
+		}
+		const match = selectGitHubRepositoryMatch(result.body, requested);
+		if (match === null) return {
+			status: 404,
+			repository: null,
+			error: `Repository ${requested} was not found in the GitHub accounts connected to Forge.`
+		};
+		return {
+			status: 200,
+			repository: describeGitHubRepository(match),
+			error: null
+		};
+	});
+}
+/**
+* Find the one repository in a brokered listing whose full name is the one
+* asked for.
+*
+* Exact and case-insensitive. The listing is a *search*, so it comes back with
+* near misses in it: asking for `owner/forge` and being handed `someone-else/
+* forge` because it sorted first is how a person ends up cloning a stranger's
+* repository, and a prefix match would do exactly that.
+*/
+function selectGitHubRepositoryMatch(body, requested) {
+	const repos = body?.repos ?? [];
+	const wanted = requested.trim().toLowerCase();
+	for (const repo of repos) if (typeof repo.full_name === "string" && repo.full_name.toLowerCase() === wanted) return repo.full_name;
+	return null;
+}
+/**
+* The repository a clone request is really for, or `null` if there is not one.
+*
+* A caller may name `owner/repo`, or paste a clone URL and let the server work
+* it out. Anything that does not resolve to a GitHub repository returns `null`
+* and must be refused rather than cloned: Forge clones through a CMMD-brokered
+* installation token for a named repository, and "just run `git clone` on this
+* URL instead" would be a second, unbrokered way to write to disk.
+*/
+function resolveGitHubCloneTarget(input) {
+	const named = input.repository?.trim();
+	if (named && /^[^/\s]+\/[^/\s]+$/.test(named)) return named;
+	if (named) return null;
+	const remoteUrl = input.remoteUrl?.trim();
+	return remoteUrl ? parseRepoFullNameFromRemoteUrl(remoteUrl) : null;
+}
+/**
+* Clone `repoFullName` for an authenticated session.
+*
+* Authorization is the caller's own CMMD connection: the session's JWT (or a
+* runtime grant, when this VM is running under one) is exchanged with CMMD for
+* an installation token scoped to that one repository. A session with no CMMD
+* connection gets 401 and no clone; a repository CMMD will not issue a token
+* for gets CMMD's own refusal, not a `git clone` attempt.
+*/
+function runGitHubCloneForSession(input) {
+	return require_Schema$1.gen(function* () {
+		const { config, repoFullName, targetDir } = input;
+		const token = yield* acquireInstallationTokenForSession(input);
+		if (!token.ok) return token.outcome;
+		const cloneDir = resolveGitHubCloneDir(config.baseDir, repoFullName, targetDir);
+		yield* require_Schema$1.promise(() => (0, node_fs_promises.mkdir)((0, node_path.join)(cloneDir, ".."), { recursive: true }).catch(() => void 0));
+		const target = {
+			cloneDir,
+			repoFullName,
+			token: token.token,
+			config
+		};
+		return (0, node_fs.existsSync)(cloneDir) ? yield* adoptExistingGitHubClone(target) : yield* cloneGitHubRepositoryInto(target);
+	});
+}
+/**
+* The installation token for one repository, on the caller's own authority.
+*
+* A runtime grant is used as-is. A session resolves its CMMD JWT and retries
+* once with a refreshed one when CMMD answers 401 or 403, because the cached
+* JWT may simply have expired. The failure branch is already the HTTP outcome,
+* so a caller returns it rather than translating it.
+*/
+function acquireInstallationTokenForSession(input) {
+	return require_Schema$1.gen(function* () {
+		const { runtimeGrantAuth, repoFullName } = input;
+		const jwt = runtimeGrantAuth ? null : yield* resolveJwt(input.sessionId, input.subject);
+		if (!runtimeGrantAuth && !jwt) return {
+			ok: false,
+			outcome: {
+				status: 401,
+				body: { error: "CMMD not connected" }
+			}
+		};
+		let token = yield* fetchInstallationTokenForAuth(runtimeGrantAuth ?? {
+			kind: "cmmd-jwt",
+			jwt
+		}, repoFullName);
+		if (!runtimeGrantAuth && !token.ok && shouldRetryWithRefreshedCmmdJwt(token.status)) {
+			const refreshedJwt = yield* resolveJwt(input.sessionId, input.subject, true);
+			if (refreshedJwt && refreshedJwt !== jwt) token = yield* fetchInstallationTokenForAuth({
+				kind: "cmmd-jwt",
+				jwt: refreshedJwt
+			}, repoFullName);
+		}
+		if (!token.ok) return {
+			ok: false,
+			outcome: {
+				status: token.status,
+				body: gitHubTokenFailureBody(token.status, token.error)
+			}
+		};
+		return {
+			ok: true,
+			token: token.token
+		};
+	});
+}
+/**
+* A directory already sits where the clone would go. Adopt it when it is a
+* checkout of the same repository, so a second "add project" is a no-op with
+* fresh credentials rather than a failure; refuse otherwise, naming the
+* folder, because overwriting it would destroy something the person made.
+*/
+function adoptExistingGitHubClone(target) {
+	return require_Schema$1.gen(function* () {
+		const { cloneDir, repoFullName } = target;
+		const git = (args) => require_Schema$1.promise(() => runProcess("git", [
 			"-C",
 			cloneDir,
-			"rev-parse",
-			"--is-inside-work-tree"
+			...args
 		], {
 			timeoutMs: 1e4,
 			allowNonZeroExit: true,
 			env: process.env
 		}));
-		const remote = yield* require_Schema$1.promise(() => runProcess("git", [
-			"-C",
-			cloneDir,
+		const workTree = yield* git(["rev-parse", "--is-inside-work-tree"]);
+		const remote = yield* git([
 			"remote",
 			"get-url",
 			"origin"
-		], {
-			timeoutMs: 1e4,
-			allowNonZeroExit: true,
-			env: process.env
-		}));
-		if (workTree.code === 0 && workTree.stdout.trim() === "true" && remote.code === 0 && isGitHubRemoteForRepo(remote.stdout.trim(), repo_full_name)) {
-			yield* applyGitCredentials({
-				cloneDir,
-				repoFullName: repo_full_name,
-				token: gitToken,
-				mode: config.forgeGitCredentialCache ? "cache" : "embed"
-			});
-			return json$6({
+		]);
+		if (!(workTree.code === 0 && workTree.stdout.trim() === "true" && remote.code === 0 && isGitHubRemoteForRepo(remote.stdout.trim(), repoFullName))) return {
+			status: 409,
+			body: {
+				error: "A project folder with that name already exists, but it is not the selected GitHub repository. Rename the import, remove the VM folder, or choose a different repository.",
+				local_path: cloneDir
+			}
+		};
+		yield* applyGitCredentialsFor(target);
+		return {
+			status: 200,
+			body: {
 				local_path: cloneDir,
 				existing: true
-			});
-		}
-		return json$6({
-			error: "A project folder with that name already exists, but it is not the selected GitHub repository. Rename the import, remove the VM folder, or choose a different repository.",
-			local_path: cloneDir
-		}, 409);
-	}
-	const result = yield* require_Schema$1.promise(() => runProcess("git", buildAuthenticatedGitCloneArgs(repo_full_name, cloneDir), {
-		timeoutMs: 12e4,
-		allowNonZeroExit: true,
-		env: {
-			...process.env,
-			CMMD_FORGE_GIT_TOKEN: gitToken,
-			GIT_TERMINAL_PROMPT: "0"
+			}
+		};
+	});
+}
+function cloneGitHubRepositoryInto(target) {
+	return require_Schema$1.gen(function* () {
+		const { cloneDir, repoFullName, token } = target;
+		const result = yield* require_Schema$1.promise(() => runProcess("git", buildAuthenticatedGitCloneArgs(repoFullName, cloneDir), {
+			timeoutMs: 12e4,
+			allowNonZeroExit: true,
+			env: {
+				...process.env,
+				CMMD_FORGE_GIT_TOKEN: token,
+				GIT_TERMINAL_PROMPT: "0"
+			}
+		}));
+		if (result.code !== 0) {
+			const stderr = sanitizeGitCredentialText(result.stderr).trim().slice(0, 500);
+			return {
+				status: 500,
+				body: { error: `git clone failed${stderr.length > 0 ? `: ${stderr}` : ""}` }
+			};
 		}
-	}));
-	if (result.code !== 0) {
-		const stderr = sanitizeGitCredentialText(result.stderr).trim().slice(0, 500);
-		return json$6({ error: `git clone failed${stderr.length > 0 ? `: ${stderr}` : ""}` }, 500);
+		yield* applyGitCredentialsFor(target);
+		return {
+			status: 200,
+			body: { local_path: cloneDir }
+		};
+	});
+}
+function applyGitCredentialsFor(target) {
+	return applyGitCredentials({
+		cloneDir: target.cloneDir,
+		repoFullName: target.repoFullName,
+		token: target.token,
+		mode: target.config.forgeGitCredentialCache ? "cache" : "embed"
+	});
+}
+const githubCloneRouteLayer = add$1("POST", "/.well-known/forge/github/clone", require_Schema$1.gen(function* () {
+	const request = yield* require_HttpServer.HttpServerRequest;
+	const session = yield* (yield* ServerAuth).authenticateHttpRequest(request);
+	const config = yield* ServerConfig;
+	if (session.method === "proxy-asserted") {
+		const forwardedJwt = normalizeForwardedCmmdJwt(request.headers);
+		if (forwardedJwt !== void 0) yield* setCommandJwtForSession(session.sessionId, forwardedJwt).pipe(require_Schema$1.ignore({ log: true }));
 	}
-	yield* applyGitCredentials({
-		cloneDir,
+	const rawBody = yield* request.json;
+	const parsed = require_Schema$1.decodeUnknownExit(CloneBodySchema)(rawBody);
+	if (parsed._tag === "Failure") return json$6({ error: "repo_full_name is required" }, 400);
+	const { repo_full_name, target_dir } = parsed.value;
+	const outcome = yield* runGitHubCloneForSession({
+		config,
+		sessionId: session.sessionId,
+		subject: session.subject,
+		runtimeGrantAuth: resolveRuntimeGitHubGrantAuth(config, request.headers),
 		repoFullName: repo_full_name,
-		token: gitToken,
-		mode: config.forgeGitCredentialCache ? "cache" : "embed"
+		targetDir: target_dir
 	});
-	return json$6({ local_path: cloneDir });
+	return json$6(outcome.body, outcome.status);
 }).pipe(require_Schema$1.catchTag("AuthError", respondToAuthError)));
 const githubCloneJobStartRouteLayer = add$1("POST", "/.well-known/forge/github/clone-jobs", require_Schema$1.gen(function* () {
 	const request = yield* require_HttpServer.HttpServerRequest;
@@ -96204,33 +96971,34 @@ function serializeNativeToolActivity(activity) {
 		}
 	};
 }
-/** The failure activities `appendProviderFailureActivity` emits, all `provider.*.failed`. */
-function isProviderFailureActivity(activity) {
-	return activity.kind.startsWith("provider.") && activity.kind.endsWith(".failed");
+function isReplicatedFailureActivity(activity) {
+	return activity.kind === "runtime.error" || activity.kind.startsWith("provider.") && activity.kind.endsWith(".failed");
 }
 function failureDetail(activity) {
 	const payload = activity.payload;
-	if (!payload || typeof payload !== "object" || !("detail" in payload)) return null;
-	const detail = payload.detail;
-	return typeof detail === "string" && detail.trim() ? detail.trim() : null;
+	if (!payload || typeof payload !== "object") return null;
+	const record = payload;
+	const detail = typeof record.detail === "string" ? record.detail.trim() : "";
+	if (detail) return detail;
+	return (typeof record.message === "string" ? record.message.trim() : "") || null;
 }
 /**
 * Replicates why a turn failed.
 *
-* Without this a failure never crossed the replication boundary — only `tool.`
-* activities were serialized — so durable history could not show one and every
+* Without this a failure never crossed the replication boundary. Only `tool.`
+* activities were serialized, so durable history could not show one and every
 * failure reached the user as an endless "Working" spinner. Measured in
 * production on 2026-08-30: zero failure events had EVER been recorded against
 * 652 tool_call rows, which is how a workspace-path block, a broker-token
 * refusal and a dispatch into a deleted directory all looked identical.
 *
-* `error_summary` is used rather than a new kind because both the Forge
-* protocol and CMMD's ingest schema already accept it; nothing here needed a
-* contract change. The detail carries the actionable sentence, so it is joined
-* onto the summary — the event has no separate detail field.
+* `error_summary` is used because both the Forge protocol and CMMD's ingest
+* schema already accept it. Provider startup failures store `detail`, while
+* active runtime failures store `message`. The event has no separate detail
+* field, so either value is joined onto the summary.
 */
-function serializeProviderFailureActivity(activity) {
-	if (!isProviderFailureActivity(activity)) return null;
+function serializeFailureActivity(activity) {
+	if (!isReplicatedFailureActivity(activity)) return null;
 	const summary = text(activity.summary, 4e3);
 	if (summary === null) return null;
 	const detail = failureDetail(activity);
@@ -96572,7 +97340,7 @@ function isTurnUsageTokens(value) {
 function serializeRuntimeThreadEvents(thread) {
 	const messages = thread.messages.flatMap(serializeThreadMessage);
 	const failureActivities = thread.activities.flatMap((activity) => {
-		const event = serializeProviderFailureActivity(activity);
+		const event = serializeFailureActivity(activity);
 		return event === null ? [] : [event];
 	});
 	const replicaActivities = thread.activities.flatMap((activity) => {
@@ -100840,6 +101608,31 @@ function claudeWriteToken(env = process.env) {
 	return accessor.read(env);
 }
 //#endregion
+//#region ../../packages/shared/src/claudeReadinessReason.ts
+/**
+* The reason literals Forge acts on, confirmed against CMMD-36441's readiness
+* service. If the route renames one, the rename lands here as a fall-through
+* to null, never as the wrong kind.
+*
+* Reading the reason is what makes `stale` legible. CMMD-36441 answers
+* `credential_reconnect_required` on a `stale` answer that still reports
+* `connected: true`, and the older `credential_generation_not_applied` on a
+* `stale` answer that simply has not landed yet. Those want opposite
+* handling, and both used to get "Reconnect Claude in Settings" because the
+* guard read only the delivery status.
+*/
+const CODE_BY_UPSTREAM_REASON$1 = {
+	credential_expired_refreshing: "CREDENTIAL_EXPIRED_REFRESHING",
+	credential_reconnect_required: "CREDENTIAL_RECONNECT_REQUIRED",
+	credential_not_connected: "CREDENTIAL_RECONNECT_REQUIRED",
+	credential_generation_not_applied: "CREDENTIAL_GENERATION_NOT_APPLIED",
+	runtime_unavailable: "RUNTIME_UNAVAILABLE"
+};
+function claudeReadinessReasonCode(reason) {
+	if (typeof reason !== "string" || !Object.hasOwn(CODE_BY_UPSTREAM_REASON$1, reason)) return null;
+	return CODE_BY_UPSTREAM_REASON$1[reason] ?? null;
+}
+//#endregion
 //#region src/egress/providerDeliveryReceipt.ts
 const PROVIDER_ACCOUNT_IDENTITY$2 = /^pai_v1_[A-Za-z0-9_-]{43}$/;
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
@@ -101014,82 +101807,6 @@ function providerDeliveryBindingsEqual(left, right) {
 	return classifyProviderDeliveryBindingChange(left, right) === "unchanged";
 }
 //#endregion
-//#region src/provider/claudeReadinessReason.ts
-/**
-* The reason literals Forge has copy for, confirmed against CMMD-36441's
-* readiness service. If the route renames one, the rename lands here as a
-* fall-through to the generic sentence, never as a wrong sentence.
-*
-* Reading the reason is what makes `stale` legible. CMMD-36441 answers
-* `credential_reconnect_required` on a `stale` answer that still reports
-* `connected: true`, and the older `credential_generation_not_applied` on a
-* `stale` answer that simply has not landed yet. Those want opposite
-* sentences, and both used to get "Reconnect Claude in Settings" because the
-* guard read only the delivery status.
-*/
-const CODE_BY_UPSTREAM_REASON$1 = {
-	credential_expired_refreshing: "CREDENTIAL_EXPIRED_REFRESHING",
-	credential_reconnect_required: "CREDENTIAL_RECONNECT_REQUIRED",
-	credential_not_connected: "CREDENTIAL_RECONNECT_REQUIRED",
-	credential_generation_not_applied: "CREDENTIAL_GENERATION_NOT_APPLIED",
-	runtime_unavailable: "RUNTIME_UNAVAILABLE"
-};
-const CLAUDE_NATIVE_CREDENTIAL_UNUSABLE_COPY = "The delivered Claude credential is unavailable or unusable in this runtime.";
-/**
-* An ISO 8601 instant, with or without fractional seconds, UTC or offset.
-* Anchored to nothing on purpose: CMMD wraps the time in a sentence, and the
-* time is the only part of that sentence Forge repeats.
-*/
-const ISO_INSTANT_PATTERN = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})/;
-function claudeReadinessReasonCode(reason) {
-	if (typeof reason !== "string" || !Object.hasOwn(CODE_BY_UPSTREAM_REASON$1, reason)) return null;
-	return CODE_BY_UPSTREAM_REASON$1[reason] ?? null;
-}
-function expiredAtFromReadinessMessage(message) {
-	if (typeof message !== "string") return null;
-	return ISO_INSTANT_PATTERN.exec(message)?.[0] ?? null;
-}
-function claudeCredentialExpiredTurnCopy(expiredAt) {
-	return `The delivered Claude credential expired at ${expiredAt}. CMMD is delivering a refreshed one, so retry this turn in a moment.`;
-}
-function claudeCredentialExpiredCardCopy(expiredAt) {
-	return `The delivered Claude credential expired at ${expiredAt}. CMMD is delivering a refreshed one to this runtime.`;
-}
-/**
-* The last allowlisted readiness reason this process saw.
-*
-* A server process serves exactly one runtime, so one slot is the whole store.
-* It holds a reason code and a timestamp, never credential bytes. The provider
-* catalog reads a local credential file and cannot tell an expired snapshot
-* from a blank one, so without this the card can only offer the generic
-* sentence while the guard already knows better.
-*/
-let latestVerdict = null;
-/**
-* Remember, or clear, what the readiness answer said.
-*
-* An answer carrying no allowlisted reason clears the slot, which is what makes
-* the card go back to the generic sentence the moment CMMD applies a
-* credential: an applied answer carries no reason.
-*/
-function recordClaudeReadinessVerdict(readiness) {
-	const code = claudeReadinessReasonCode(readiness.reason);
-	latestVerdict = code === null ? null : {
-		code,
-		expiredAt: expiredAtFromReadinessMessage(readiness.lastErrorMessage)
-	};
-}
-/**
-* What the provider status card says about a delivered credential it cannot
-* use. Names the expiry only when a readiness answer supplied the time; a
-* guessed time would be worse than the generic sentence.
-*/
-function claudeNativeCredentialUnusableMessage() {
-	const verdict = latestVerdict;
-	if (verdict?.code === "CREDENTIAL_EXPIRED_REFRESHING" && verdict.expiredAt !== null) return claudeCredentialExpiredCardCopy(verdict.expiredAt);
-	return CLAUDE_NATIVE_CREDENTIAL_UNUSABLE_COPY;
-}
-//#endregion
 //#region src/provider/providerReadiness.ts
 const GENERATION_HASH_PATTERN$1 = /^[a-f0-9]{64}$/;
 const STILL_APPLYING_STATUSES = new Set([
@@ -101134,10 +101851,18 @@ async function queryProviderReadiness(input) {
 	}
 	return classifyClaudeSnapshot(snapshot, sprite);
 }
-function isAppliedClaudeSnapshot(snapshot) {
-	return snapshot.connected === true && snapshot.deliveryStatus === "applied" && snapshot.nativeExecutable === true && typeof snapshot.generationId === "string" && snapshot.generationId.trim().length > 0;
+/**
+* Whether CMMD allows a turn to start on this runtime. The delivery status is
+* not part of it: a refresh that failed over a credential the guest verified
+* and that has not expired reads as failed with nativeExecutable true, and the
+* turn is the probe (FOR-3085). The generation fence and the receipt below
+* still bind the answer.
+*/
+function claudeSnapshotAllowsTurn(snapshot) {
+	return snapshot.connected === true && snapshot.nativeExecutable === true && typeof snapshot.generationId === "string" && snapshot.generationId.trim().length > 0;
 }
-function classifyUnappliedClaudeSnapshot(snapshot) {
+/** Why a turn may not start, for an answer that does not allow one. */
+function classifyClaudeTurnRefusal(snapshot) {
 	const code = claudeReadinessReasonCode(snapshot.reason);
 	if (code === "RUNTIME_UNAVAILABLE") return {
 		kind: "not_ready",
@@ -101165,7 +101890,7 @@ function classifyUnappliedClaudeSnapshot(snapshot) {
 	};
 }
 function classifyClaudeSnapshot(snapshot, sprite) {
-	if (!isAppliedClaudeSnapshot(snapshot)) return classifyUnappliedClaudeSnapshot(snapshot);
+	if (!claudeSnapshotAllowsTurn(snapshot)) return classifyClaudeTurnRefusal(snapshot);
 	const generationId = snapshot.generationId.trim();
 	if ((0, node_crypto.createHash)("sha256").update(generationId).digest("hex") !== sprite.localGenerationHash) return {
 		kind: "not_ready",
@@ -104511,7 +105236,9 @@ const REJECT_UNCERTAIN_METHODS = new Set([
 	WS_METHODS.pullRequestsComment,
 	WS_METHODS.pullRequestsSubmitReview,
 	WS_METHODS.pullRequestsReplyToThread,
-	WS_METHODS.projectCheckoutDeletionExecute
+	WS_METHODS.projectCheckoutDeletionExecute,
+	WS_METHODS.providerUploadFeedback,
+	WS_METHODS.sourceControlCloneRepository
 ]);
 function classifyInterruptedRelayCommand(input) {
 	if ((input.method === WS_METHODS.gitCreateBranch || input.method === WS_METHODS.vcsCreateRef) && input.deliveryClass === "create-command") return { kind: "reconcile-git-create-branch" };
@@ -105443,7 +106170,77 @@ const makeWsRpcLayer = (currentSessionId, currentUserId) => WsRpcGroup.toLayer(r
 				payload: initialSnapshot
 			}), liveEvents);
 		}), { "rpc.aggregate": "auth" }),
-		[WS_METHODS.subscribeWorkspaceReadiness]: (_input) => currentUserId === void 0 ? require_Path.empty : workspaceReadinessState.subscribe(currentUserId)
+		[WS_METHODS.subscribeWorkspaceReadiness]: (_input) => currentUserId === void 0 ? require_Path.empty : workspaceReadinessState.subscribe(currentUserId),
+		[WS_METHODS.assetsCreateUrl]: (input) => observeRpcEffect(WS_METHODS.assetsCreateUrl, createAssetUrl(currentSessionId, input.resource), { "rpc.aggregate": "assets" }),
+		[WS_METHODS.providerUploadFeedback]: (input) => observeRpcEffect(WS_METHODS.providerUploadFeedback, uploadThreadFeedback(orchestrationEngine, currentSessionId, currentUserId, input), { "rpc.aggregate": "provider" }),
+		[ORCHESTRATION_WS_METHODS.searchThreads]: (input) => observeRpcEffect(ORCHESTRATION_WS_METHODS.searchThreads, require_Schema$1.gen(function* () {
+			yield* startup.awaitCommandReady;
+			return yield* projectionSnapshotQuery.searchThreads(input);
+		}).pipe(require_Schema$1.mapError((cause) => new OrchestrationSearchThreadsError({
+			message: "Failed to search threads",
+			cause
+		}))), { "rpc.aggregate": "orchestration" }),
+		[WS_METHODS.sourceControlLookupRepository]: (input) => observeRpcEffect(WS_METHODS.sourceControlLookupRepository, require_Schema$1.gen(function* () {
+			if (input.provider !== "github") return yield* new SourceControlRepositoryError({
+				provider: input.provider,
+				operation: "lookupRepository",
+				detail: `Forge can only look up GitHub repositories. ${input.provider} is not connected.`
+			});
+			if (currentUserId === void 0) return yield* new SourceControlRepositoryError({
+				provider: "github",
+				operation: "lookupRepository",
+				detail: "Sign in to Forge before looking up a repository."
+			});
+			const outcome = yield* lookupGitHubRepositoryForSession({
+				sessionId: currentSessionId,
+				subject: currentUserId,
+				runtimeGrantAuth: null,
+				repository: input.repository
+			});
+			if (outcome.repository === null) return yield* new SourceControlRepositoryError({
+				provider: "github",
+				operation: "lookupRepository",
+				detail: outcome.error ?? "Repository lookup failed."
+			});
+			return {
+				provider: "github",
+				...outcome.repository
+			};
+		}), { "rpc.aggregate": "sourceControl" }),
+		[WS_METHODS.sourceControlCloneRepository]: (input) => observeRpcEffect(WS_METHODS.sourceControlCloneRepository, require_Schema$1.gen(function* () {
+			const provider = input.provider ?? "github";
+			const repoFullName = resolveGitHubCloneTarget(input);
+			const refuse = (detail) => new SourceControlRepositoryError({
+				provider,
+				operation: "cloneRepository",
+				detail
+			});
+			if (provider !== "github") return yield* refuse(`Forge can only clone GitHub repositories. ${provider} is not connected.`);
+			if (currentUserId === void 0) return yield* refuse("Sign in to Forge before cloning a repository.");
+			if (repoFullName === null) return yield* refuse("Name the repository as owner/name, or paste a github.com clone URL.");
+			const outcome = yield* runGitHubCloneForSession({
+				config,
+				sessionId: currentSessionId,
+				subject: currentUserId,
+				runtimeGrantAuth: null,
+				repoFullName,
+				targetDir: input.destinationPath
+			});
+			const localPath = outcome.body.local_path;
+			if (outcome.status !== 200 || typeof localPath !== "string") {
+				const detail = outcome.body.error;
+				return yield* refuse(typeof detail === "string" ? detail : "Cloning the repository failed.");
+			}
+			const repository = describeGitHubRepository(repoFullName);
+			return {
+				cwd: localPath,
+				remoteUrl: repository.url,
+				repository: {
+					provider: "github",
+					...repository
+				}
+			};
+		}), { "rpc.aggregate": "sourceControl" })
 	});
 }));
 const websocketRpcRouteLayer = require_Schema$1.unwrap(require_Schema$1.succeed(require_Schema$1.mergeAll(add$1("GET", "/ws", require_Schema$1.gen(function* () {
@@ -116531,8 +117328,8 @@ require_Schema$1.effectDiscard(runMigrations());
 //#endregion
 //#region src/persistence/Layers/Sqlite.ts
 const defaultSqliteClientLoaders = {
-	bun: () => Promise.resolve().then(() => require("./SqliteClient-B08FzZM4.cjs")),
-	node: () => Promise.resolve().then(() => require("./NodeSqliteClient-CmxPzcBf.cjs"))
+	bun: () => Promise.resolve().then(() => require("./SqliteClient-Cq1peWN1.cjs")),
+	node: () => Promise.resolve().then(() => require("./NodeSqliteClient-qjBWAOGq.cjs"))
 };
 const makeRuntimeSqliteLayer = require_Schema$1.fn("makeRuntimeSqliteLayer")(function* (config) {
 	const loader = defaultSqliteClientLoaders[process.versions.bun !== void 0 ? "bun" : "node"];
@@ -211732,6 +212529,83 @@ const makeProviderAuthProvenance = (input) => {
 	};
 };
 //#endregion
+//#region src/provider/claudeReadinessReason.ts
+/**
+* What Forge says about a delivered Claude credential that expired.
+*
+* CMMD's credential authority rotates the refresh token on every refresh, and a
+* runtime holds a one-time snapshot, so the snapshot's refresh token dies at
+* the next rotation. Nothing re-delivers on its own, and on 2026-09-04 23:07Z
+* the turn met a dead credential: the CLI said "OAuth session expired and could
+* not be refreshed", the thread said Claude was unavailable on this
+* Environment, and the provider card said the credential was "unavailable or
+* unusable". Three sentences, none of them the fact, which is that the
+* credential expired at a known time and a replacement is on its way.
+*
+* CMMD-36441 now answers the pre-turn readiness read with a typed reason and
+* queues a same-generation re-delivery. This module is the one place that
+* turns those reasons into words.
+*
+* Which kind of answer a reason names comes from
+* `@cmmd-forge/shared/claudeReadinessReason`, which the browser readiness poll
+* reads too, so the two cannot disagree about a reason (FOR-3085). A reason
+* that maps to nothing falls through to the generic copy, and every sentence a
+* person reads is written here rather than forwarded from upstream. Only an
+* ISO timestamp is ever lifted out of CMMD's message, so no credential detail
+* in an upstream string can reach a browser.
+*/
+const CLAUDE_NATIVE_CREDENTIAL_UNUSABLE_COPY = "The delivered Claude credential is unavailable or unusable in this runtime.";
+/**
+* An ISO 8601 instant, with or without fractional seconds, UTC or offset.
+* Anchored to nothing on purpose: CMMD wraps the time in a sentence, and the
+* time is the only part of that sentence Forge repeats.
+*/
+const ISO_INSTANT_PATTERN = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})/;
+function expiredAtFromReadinessMessage(message) {
+	if (typeof message !== "string") return null;
+	return ISO_INSTANT_PATTERN.exec(message)?.[0] ?? null;
+}
+function claudeCredentialExpiredTurnCopy(expiredAt) {
+	return `The delivered Claude credential expired at ${expiredAt}. CMMD is delivering a refreshed one, so retry this turn in a moment.`;
+}
+function claudeCredentialExpiredCardCopy(expiredAt) {
+	return `The delivered Claude credential expired at ${expiredAt}. CMMD is delivering a refreshed one to this runtime.`;
+}
+/**
+* The last allowlisted readiness reason this process saw.
+*
+* A server process serves exactly one runtime, so one slot is the whole store.
+* It holds a reason code and a timestamp, never credential bytes. The provider
+* catalog reads a local credential file and cannot tell an expired snapshot
+* from a blank one, so without this the card can only offer the generic
+* sentence while the guard already knows better.
+*/
+let latestVerdict = null;
+/**
+* Remember, or clear, what the readiness answer said.
+*
+* An answer carrying no allowlisted reason clears the slot, which is what makes
+* the card go back to the generic sentence the moment CMMD applies a
+* credential: an applied answer carries no reason.
+*/
+function recordClaudeReadinessVerdict(readiness) {
+	const code = claudeReadinessReasonCode(readiness.reason);
+	latestVerdict = code === null ? null : {
+		code,
+		expiredAt: expiredAtFromReadinessMessage(readiness.lastErrorMessage)
+	};
+}
+/**
+* What the provider status card says about a delivered credential it cannot
+* use. Names the expiry only when a readiness answer supplied the time; a
+* guessed time would be worse than the generic sentence.
+*/
+function claudeNativeCredentialUnusableMessage() {
+	const verdict = latestVerdict;
+	if (verdict?.code === "CREDENTIAL_EXPIRED_REFRESHING" && verdict.expiredAt !== null) return claudeCredentialExpiredCardCopy(verdict.expiredAt);
+	return CLAUDE_NATIVE_CREDENTIAL_UNUSABLE_COPY;
+}
+//#endregion
 //#region src/provider/claudeCredentialStore.ts
 /**
 * Which Credential Store the Claude CLI uses on this machine, read the way the
@@ -287415,6 +288289,7 @@ function taskStartedToActivities(event) {
 		summary: taskStartedSummary(event.payload.taskType),
 		payload: {
 			taskId: event.payload.taskId,
+			agentKind: classifyTaskAgentKind({ taskType: event.payload.taskType }),
 			...event.payload.taskType ? { taskType: event.payload.taskType } : {},
 			...event.payload.description ? { detail: truncateDetail(event.payload.description) } : {}
 		}
@@ -295274,7 +296149,7 @@ function resolveBuildCommitFromEnv(env) {
 * environment descriptor down instead of reporting an honest "unknown".
 */
 function readBakedBuildCommit() {
-	return "69affcc8397652715f8bd06fe2f226f4b607e1db";
+	return "c220fa73834b4651c7fc65f272c171028edc3e81";
 }
 async function resolveServerBuildCommit(input) {
 	if (isFullCommitSha(input.baked)) return input.baked;
@@ -295391,6 +296266,7 @@ function executionEnvironmentCapabilities(serverConfig) {
 		pullRequests: isExecutionPlane,
 		threadPullRequestLinking: isExecutionPlane,
 		threadSettlement: isExecutionPlane,
+		threadTitleRegeneration: isExecutionPlane,
 		cloudMode: serverConfig.forgeCmmdRuntimeMode === true || isCloudShell,
 		runtime: {
 			topology: runtimeTopology(serverConfig),
@@ -295676,10 +296552,6 @@ const pulseSignalStateUpsertRouteLayer = add$1("POST", "/api/pulse/signals/state
 	});
 }).pipe(require_Schema$1.catchTag("AuthError", respondToAuthError)));
 //#endregion
-//#region src/auth/Services/ServerSecretStore.ts
-var SecretStoreError = class extends require_Schema$1.TaggedError("SecretStoreError") {};
-var ServerSecretStore = class extends require_Schema$1.Service()("forge/auth/Services/ServerSecretStore") {};
-//#endregion
 //#region src/auth/Layers/ServerSecretStore.ts
 const OWNED_FILE_RECEIPT_PREFIX = "forge-owned-secret-receipt:v1:";
 const LEGACY_FILE_SECRET_NAMESPACE_PREFIX = "forge-secret-namespace:v1:";
@@ -302052,6 +302924,55 @@ const ProjectionCountsRowSchema = require_Schema$1.Struct({
 const WorkspaceRootLookupInput = require_Schema$1.Struct({ workspaceRoot: require_Schema$1.String });
 const ProjectIdLookupInput = require_Schema$1.Struct({ projectId: ProjectId });
 const ThreadIdLookupInput = require_Schema$1.Struct({ threadId: ThreadId });
+const ThreadSearchQueryInput = require_Schema$1.Struct({
+	pattern: require_Schema$1.String,
+	limit: require_Schema$1.Number
+});
+const ThreadSearchMessageRowSchema = require_Schema$1.Struct({
+	threadId: ThreadId,
+	projectId: ProjectId,
+	role: require_Schema$1.String,
+	text: require_Schema$1.String,
+	createdAt: IsoDateTime
+});
+const ThreadSearchMetadataRowSchema = require_Schema$1.Struct({
+	threadId: ThreadId,
+	projectId: ProjectId,
+	title: require_Schema$1.String,
+	branch: require_Schema$1.NullOr(require_Schema$1.String)
+});
+/** The contract caps a snippet at this length, so the server must too. */
+const THREAD_SEARCH_SNIPPET_LIMIT = 240;
+/** How many matches a search returns when the caller does not say. */
+const THREAD_SEARCH_DEFAULT_LIMIT = 20;
+/**
+* `LIKE` treats `%` and `_` as wildcards, so a person searching for a literal
+* underscore (every other identifier in a codebase) would otherwise match any
+* character. Escaped with a backslash, declared to SQL as `ESCAPE '\'`, and
+* lowercased on both sides because Postgres `LIKE` is case-sensitive where
+* SQLite's is not, and Forge runs on both.
+*/
+function toThreadSearchPattern(query) {
+	return `%${query.toLowerCase().replace(/[\\%_]/g, (character) => `\\${character}`)}%`;
+}
+/**
+* A window of the text around the first hit, not the head of it.
+*
+* A match 4000 characters into an assistant message is invisible in a snippet
+* that always starts at character zero, which is the difference between a
+* result a person can recognize and a result they have to open to understand.
+*/
+function buildThreadSearchSnippet(text, lowerQuery) {
+	const collapsed = text.replace(/\s+/g, " ").trim();
+	if (collapsed.length <= THREAD_SEARCH_SNIPPET_LIMIT) return collapsed;
+	const matchIndex = collapsed.toLowerCase().indexOf(lowerQuery);
+	if (matchIndex < 0) return `${collapsed.slice(0, THREAD_SEARCH_SNIPPET_LIMIT - 1)}…`;
+	const leading = Math.floor((THREAD_SEARCH_SNIPPET_LIMIT - lowerQuery.length) / 2);
+	const start = Math.max(0, matchIndex - Math.max(leading, 0));
+	const windowed = collapsed.slice(start, start + THREAD_SEARCH_SNIPPET_LIMIT);
+	const prefixed = start > 0 ? `…${windowed}` : windowed;
+	return prefixed.length > THREAD_SEARCH_SNIPPET_LIMIT ? prefixed.slice(0, THREAD_SEARCH_SNIPPET_LIMIT) : prefixed;
+}
 const ProjectionProjectLookupRowSchema = ProjectionProjectDbRowSchema;
 const ProjectionThreadIdLookupRowSchema = require_Schema$1.Struct({ threadId: ThreadId });
 const ProjectionThreadCheckpointContextThreadRowSchema = require_Schema$1.Struct({
@@ -302297,6 +303218,61 @@ const makeProjectionSnapshotQuery = require_Schema$1.gen(function* () {
           AND deleted_at IS NULL
           AND archived_at IS NULL
         ORDER BY created_at ASC, thread_id ASC
+      `
+	});
+	/**
+	* Message bodies containing the query.
+	*
+	* `role IN ('user', 'assistant')` is not a filter for tidiness: the match
+	* shape on the wire names one of those two as the side the hit came from,
+	* and a system message has no side to report. Ordered newest first because a
+	* capped search should keep what the person is most likely still thinking
+	* about.
+	*/
+	const searchThreadMessageRows = findAll({
+		Request: ThreadSearchQueryInput,
+		Result: ThreadSearchMessageRowSchema,
+		execute: ({ pattern, limit }) => sql`
+        SELECT
+          m.thread_id AS "threadId",
+          t.project_id AS "projectId",
+          m.role AS "role",
+          m.text AS "text",
+          m.created_at AS "createdAt"
+        FROM projection_thread_messages AS m
+        JOIN projection_threads AS t ON t.thread_id = m.thread_id
+        WHERE t.deleted_at IS NULL
+          AND m.role IN ('user', 'assistant')
+          AND LOWER(m.text) LIKE ${pattern} ESCAPE '\\'
+        ORDER BY m.created_at DESC, m.message_id ASC
+        LIMIT ${limit}
+      `
+	});
+	/**
+	* Threads whose own metadata contains the query.
+	*
+	* Title and branch, which is what the web command palette matches on. Title
+	* is duplicated work for a client that already filters its in-memory list,
+	* and harmless because matches are deduplicated by thread; branch is not,
+	* because no client holds every branch.
+	*/
+	const searchThreadMetadataRows = findAll({
+		Request: ThreadSearchQueryInput,
+		Result: ThreadSearchMetadataRowSchema,
+		execute: ({ pattern, limit }) => sql`
+        SELECT
+          thread_id AS "threadId",
+          project_id AS "projectId",
+          title,
+          branch
+        FROM projection_threads
+        WHERE deleted_at IS NULL
+          AND (
+            LOWER(title) LIKE ${pattern} ESCAPE '\\'
+            OR LOWER(branch) LIKE ${pattern} ESCAPE '\\'
+          )
+        ORDER BY updated_at DESC, thread_id ASC
+        LIMIT ${limit}
       `
 	});
 	/**
@@ -303043,6 +304019,40 @@ const makeProjectionSnapshotQuery = require_Schema$1.gen(function* () {
 	};
 	const getShellSnapshot = () => readShellSnapshot("getShellSnapshot", listThreadRows);
 	const getArchivedShellSnapshot = () => readShellSnapshot("getArchivedShellSnapshot", listArchivedThreadRows);
+	const searchThreads = (input) => {
+		const limit = input.limit ?? THREAD_SEARCH_DEFAULT_LIMIT;
+		const lowerQuery = input.query.toLowerCase();
+		const request = {
+			pattern: toThreadSearchPattern(input.query),
+			limit
+		};
+		return require_Schema$1.all([searchThreadMessageRows(request).pipe(require_Schema$1.mapError(toPersistenceSqlOrDecodeError("ProjectionSnapshotQuery.searchThreads:messages:query", "ProjectionSnapshotQuery.searchThreads:messages:decodeRows"))), searchThreadMetadataRows(request).pipe(require_Schema$1.mapError(toPersistenceSqlOrDecodeError("ProjectionSnapshotQuery.searchThreads:metadata:query", "ProjectionSnapshotQuery.searchThreads:metadata:decodeRows")))]).pipe(require_Schema$1.map(([messageRows, metadataRows]) => {
+			const byThread = /* @__PURE__ */ new Map();
+			for (const row of messageRows) {
+				if (byThread.has(row.threadId)) continue;
+				byThread.set(row.threadId, {
+					threadId: row.threadId,
+					projectId: row.projectId,
+					source: row.role === "assistant" ? "assistant" : "user",
+					snippet: buildThreadSearchSnippet(row.text, lowerQuery),
+					messageCreatedAt: row.createdAt
+				});
+			}
+			for (const row of metadataRows) {
+				if (byThread.has(row.threadId)) continue;
+				const branchMatched = row.branch?.toLowerCase().includes(lowerQuery) === true;
+				const titleMatched = row.title.toLowerCase().includes(lowerQuery);
+				byThread.set(row.threadId, {
+					threadId: row.threadId,
+					projectId: row.projectId,
+					source: "user",
+					snippet: buildThreadSearchSnippet(titleMatched || !branchMatched ? row.title : row.branch ?? row.title, lowerQuery),
+					messageCreatedAt: null
+				});
+			}
+			return { matches: [...byThread.values()].slice(0, limit) };
+		}));
+	};
 	const listActiveWorkerShells = () => sql.withTransaction(require_Schema$1.all([
 		listActiveWorkerThreadRows(void 0).pipe(require_Schema$1.mapError(toPersistenceSqlOrDecodeError("ProjectionSnapshotQuery.listActiveWorkerShells:listThreads:query", "ProjectionSnapshotQuery.listActiveWorkerShells:listThreads:decodeRows"))),
 		listActiveWorkerSessionRows(void 0).pipe(require_Schema$1.mapError(toPersistenceSqlOrDecodeError("ProjectionSnapshotQuery.listActiveWorkerShells:listThreadSessions:query", "ProjectionSnapshotQuery.listActiveWorkerShells:listThreadSessions:decodeRows"))),
@@ -303211,6 +304221,7 @@ const makeProjectionSnapshotQuery = require_Schema$1.gen(function* () {
 		getSnapshot,
 		getShellSnapshot,
 		getArchivedShellSnapshot,
+		searchThreads,
 		listActiveWorkerShells,
 		listStaleRunningSessionShells,
 		getCounts,
@@ -318475,13 +319486,13 @@ const gitUrlCloneRouteLayer = add$1("POST", "/api/cloud/git/clone-url", require_
 //#endregion
 //#region src/server.ts
 const PtyAdapterLive = require_Schema$1.unwrap(require_Schema$1.gen(function* () {
-	if (typeof Bun !== "undefined") return (yield* require_Schema$1.promise(() => Promise.resolve().then(() => require("./BunPTY-86ttlTi6.cjs")))).layer;
-	else return (yield* require_Schema$1.promise(() => Promise.resolve().then(() => require("./NodePTY-Cps0jsDA.cjs")))).layer;
+	if (typeof Bun !== "undefined") return (yield* require_Schema$1.promise(() => Promise.resolve().then(() => require("./BunPTY-uyreNRGp.cjs")))).layer;
+	else return (yield* require_Schema$1.promise(() => Promise.resolve().then(() => require("./NodePTY-S4tPEwZc.cjs")))).layer;
 }));
 const HttpServerLive = require_Schema$1.unwrap(require_Schema$1.gen(function* () {
 	const config = yield* ServerConfig;
-	if (typeof Bun !== "undefined") return (yield* require_Schema$1.promise(() => Promise.resolve().then(() => require("./BunHttpServer-BhE7Szci.cjs")))).layer(bunHttpServerOptions(config));
-	const [NodeHttpServer, NodeHttp] = yield* require_Schema$1.all([require_Schema$1.promise(() => Promise.resolve().then(() => require("./NodeHttpServer-BPjxt_DT.cjs"))), require_Schema$1.promise(() => import("node:http"))]);
+	if (typeof Bun !== "undefined") return (yield* require_Schema$1.promise(() => Promise.resolve().then(() => require("./BunHttpServer-DKvSpNd1.cjs")))).layer(bunHttpServerOptions(config));
+	const [NodeHttpServer, NodeHttp] = yield* require_Schema$1.all([require_Schema$1.promise(() => Promise.resolve().then(() => require("./NodeHttpServer-Dfc7nSMq.cjs"))), require_Schema$1.promise(() => import("node:http"))]);
 	return NodeHttpServer.layer(NodeHttp.createServer, {
 		host: config.host,
 		port: config.port
@@ -318489,10 +319500,10 @@ const HttpServerLive = require_Schema$1.unwrap(require_Schema$1.gen(function* ()
 }));
 const PlatformServicesLive = require_Schema$1.unwrap(require_Schema$1.gen(function* () {
 	if (typeof Bun !== "undefined") {
-		const { layer } = yield* require_Schema$1.promise(() => Promise.resolve().then(() => require("./BunServices-BwE9KexF.cjs")));
+		const { layer } = yield* require_Schema$1.promise(() => Promise.resolve().then(() => require("./BunServices-DDh7Whyx.cjs")));
 		return layer;
 	} else {
-		const { layer } = yield* require_Schema$1.promise(() => Promise.resolve().then(() => require("./NodeServices-Ddr-tYRu.cjs")));
+		const { layer } = yield* require_Schema$1.promise(() => Promise.resolve().then(() => require("./NodeServices-DE8jhdcU.cjs")));
 		return layer;
 	}
 }));