import * as DocumentText from "../provider/DocumentText.ts";
import * as Scheduler from "../scheduling/Scheduler.ts";
import * as WorktreeSetupTracker from "../project/WorktreeSetupTracker.ts";
import * as ProjectCloneTracker from "../project/ProjectCloneTracker.ts";
import * as TerminalManager from "../terminal/Manager.ts";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as FileSystem from "effect/FileSystem";
import * as ServerConfig from "../config.ts";
import { createPendingAttachmentId, resolveAttachmentPath } from "../attachmentStore.ts";
import * as ThreadMessageIntake from "./ThreadMessageIntake.ts";
import { assert, it, vi } from "@effect/vitest";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import {
ChatAttachmentId,
ComposerContextId,
type ChatAttachment,
CommandId,
DEFAULT_SERVER_SETTINGS,
GitCommandError,
MessageId,
ProjectId,
ProviderDriverKind,
ProviderInstanceId,
OrchestrationV2ThreadProjectionJson,
ScheduledTaskId,
type ServerProvider,
ThreadId,
} from "@t3tools/contracts";
import * as Cause from "effect/Cause";
import * as Deferred from "effect/Deferred";
import * as DateTime from "effect/DateTime";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Ref from "effect/Ref";
import * as Result from "effect/Result";
import * as Stream from "effect/Stream";
import * as Schema from "effect/Schema";
import * as SqlClient from "effect/sql/SqlClient";
import * as TestClock from "effect/testing/TestClock";
import * as GitWorkflow from "../git/GitWorkflowService.ts";
import * as SqlitePersistence from "../persistence/Sqlite.ts";
import * as ProjectStore from "./ProjectStore.ts";
import * as ProjectService from "../project/ProjectService.ts";
import * as ProjectSetupScriptRunner from "../project/ProjectSetupScriptRunner.ts";
import * as ManagedProjectFolders from "../project/ManagedProjectFolders.ts";
import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts";
import * as ServerSettings from "../serverSettings.ts";
import * as ScheduledTasks from "../scheduledTasks/ScheduledTaskService.ts";
import * as ManagedPolicy from "../policy/ManagedPolicy.ts";
import * as SecretRequests from "../secrets/SecretRequests.ts";
import * as TextGeneration from "../textGeneration/TextGeneration.ts";
import { ClaudeProviderCapabilitiesV2 } from "./Adapters/ClaudeAdapterV2.ts";
import { CodexProviderCapabilitiesV2 } from "./Adapters/CodexAdapterV2.ts";
import * as CommandReceiptStore from "./CommandReceiptStore.ts";
import * as EffectOutbox from "./EffectOutbox.ts";
import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
import * as ProviderAdapterRegistry from "./ProviderAdapterRegistry.ts";
import * as ThreadLaunch from "./ThreadLaunchService.ts";
import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
import * as ThreadManagement from "./ThreadManagementService.ts";
import * as ThreadTitleRegeneration from "./ThreadTitleRegenerationService.ts";
import * as ProviderReplayHarness from "./testkit/ProviderReplayHarness.ts";
import * as RemoteDelegation from "../peer/RemoteDelegation.ts";
import type * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
const projectId = ProjectId.make("project:launch-test");
const otherProjectId = ProjectId.make("project:launch-other");
const encodeThreadProjection = Schema.encodeEffect(OrchestrationV2ThreadProjectionJson);
const modelSelection = {
instanceId: ProviderInstanceId.make("codex"),
model: "gpt-5.1-codex",
} as const;
const project = {
id: projectId,
title: "Project",
workspaceRoot: "/repo",
repositoryIdentity: null,
faviconPath: null,
defaultModelSelection: modelSelection,
defaultThreadEnvMode: null,
scripts: [],
pinnedAt: null,
archivedAt: null,
createdAt: "2026-06-20T00:00:00.000Z",
updatedAt: "2026-06-20T00:00:00.000Z",
deletedAt: null,
} as const;
const otherProject = {
...project,
id: otherProjectId,
title: "Other",
workspaceRoot: "/other-repo",
} as const;
const adapter = {
instanceId: modelSelection.instanceId,
driver: ProviderDriverKind.make("codex"),
getCapabilities: () => Effect.succeed(CodexProviderCapabilitiesV2),
planSelectionTransition: () => Effect.succeed({ type: "apply_on_next_turn" as const }),
openSession: () => Effect.die("provider execution is disabled in launch tests"),
} as ProviderAdapter.ProviderAdapterV2["Service"];
const claudeModelSelection = {
instanceId: ProviderInstanceId.make("claudeAgent"),
model: "claude-opus-5-5",
} as const;
const claudeAdapter = {
instanceId: claudeModelSelection.instanceId,
driver: ProviderDriverKind.make("claudeAgent"),
getCapabilities: () => Effect.succeed(ClaudeProviderCapabilitiesV2),
planSelectionTransition: () => Effect.succeed({ type: "apply_on_next_turn" as const }),
openSession: () => Effect.die("provider execution is disabled in launch tests"),
} as ProviderAdapter.ProviderAdapterV2["Service"];
interface HarnessOptions {
readonly closeTerminal?: TerminalManager.TerminalManager["Service"]["close"];
readonly adapters?: ReadonlyArray<ProviderAdapter.ProviderAdapterV2["Service"]>;
readonly managedFolders?: Layer.Layer<ManagedProjectFolders.ManagedProjectFolders>;
readonly createWorktree?: GitWorkflow.GitWorkflowService["Service"]["createWorktree"];
readonly fetchWorktreeBaseCommit?: GitWorkflow.GitWorkflowService["Service"]["fetchWorktreeBaseCommit"];
readonly remoteExists?: GitWorkflow.GitWorkflowService["Service"]["remoteExists"];
readonly hasCommit?: GitWorkflow.GitWorkflowService["Service"]["hasCommit"];
readonly renameBranch?: GitWorkflow.GitWorkflowService["Service"]["renameBranch"];
readonly runSetup?: ProjectSetupScriptRunner.ProjectSetupScriptRunner["Service"]["runForThread"];
readonly generateTitle?: TextGeneration.TextGeneration["Service"]["generateThreadTitle"];
readonly generateBranchName?: TextGeneration.TextGeneration["Service"]["generateBranchName"];
readonly serverSettings?: Parameters<typeof ServerSettings.layerTest>[0];
readonly providers?: ReadonlyArray<ServerProvider>;
readonly git?: Partial<GitWorkflow.GitWorkflowService["Service"]>;
}
function makeHarness(options: HarnessOptions = {}) {
const layerDatabase = SqlitePersistence.layerMemory;
const layerRegistry = ProviderAdapterRegistry.layerFromAdapters(options.adapters ?? [adapter]);
const layerOrchestrator = ProviderReplayHarness.layerWithRegistry(
{ name: "thread-launch" },
layerRegistry,
{ databaseLayer: layerDatabase, runEffectWorker: false },
);
const layerServerSettings = ServerSettings.layerTest(options.serverSettings);
const layerReceipts = CommandReceiptStore.layer.pipe(Layer.provide(layerDatabase));
const layerThreadManagement = ThreadManagement.layer.pipe(
Layer.provide(layerOrchestrator),
Layer.provide(layerServerSettings),
Layer.provide(layerReceipts),
);
const layerOutbox = EffectOutbox.layer.pipe(Layer.provide(layerDatabase));
const createWorktree = vi.fn(
options.createWorktree ??
((input) =>
Effect.succeed({
worktree: { path: "/repo-worktrees/feature", refName: input.newRefName, headSha: "abc" },
} as never)),
);
const renameBranch = vi.fn(
options.renameBranch ?? ((input) => Effect.succeed({ branch: input.newBranch })),
);
const removeWorktree = vi.fn(
(_input: Parameters<GitWorkflow.GitWorkflowService["Service"]["removeWorktree"]>[0]) =>
Effect.void,
);
const deleteLocalBranch = vi.fn(
(_input: Parameters<GitWorkflow.GitWorkflowService["Service"]["deleteLocalBranch"]>[0]) =>
Effect.void,
);
const runSetup = vi.fn(
options.runSetup ?? (() => Effect.succeed({ status: "no-script" as const })),
);
const closeTerminal = vi.fn(options.closeTerminal ?? (() => Effect.void));
const generateBranchName = vi.fn(
options.generateBranchName ?? (() => Effect.succeed({ branch: "generated-branch" })),
);
const generateThreadTitle = vi.fn(
options.generateTitle ?? (() => Effect.succeed({ title: "Generated title" })),
);
const layerExternalServices = Layer.mergeAll(
WorktreeSetupTracker.layer,
Layer.mock(ProjectCloneTracker.ProjectCloneTracker)({ get: () => Effect.succeed(null) }),
Layer.mock(TerminalManager.TerminalManager)({ close: closeTerminal }),
Layer.succeed(ProjectService.ProjectService, {
create: () => Effect.die("unused"),
bootstrap: () => Effect.die("unused"),
update: () => Effect.die("unused"),
delete: () => Effect.die("unused"),
listPage: () => Effect.die("unused"),
getById: (id) =>
Effect.succeed(
id === projectId
? Option.some(project)
: id === otherProjectId
? Option.some(otherProject)
: Option.none(),
),
getByWorkspaceRoot: () => Effect.succeedSome(project),
snapshot: Effect.die("unused"),
getShell: () => Effect.die("unused"),
listShells: () => Effect.die("unused"),
}),
Layer.mock(GitWorkflow.GitWorkflowService)({
createWorktree,
renameBranch,
fetchWorktreeBaseCommit:
options.fetchWorktreeBaseCommit ??
(() => Effect.succeed({ commitSha: "remote-main-sha", remoteRefName: "origin/main" })),
hasCommit: options.hasCommit ?? (() => Effect.succeed(false)),
resolveWorktreeBaseRemote: () => Effect.succeed({ remoteName: "origin", branchName: "main" }),
remoteExists: options.remoteExists ?? (() => Effect.succeed(true)),
remoteBranchExists: () => Effect.succeed(true),
removeWorktree,
deleteLocalBranch,
...options.git,
}),
Layer.succeed(ProjectSetupScriptRunner.ProjectSetupScriptRunner, {
runForThread: runSetup,
}),
Layer.mock(TextGeneration.TextGeneration)({
generateThreadTitle,
generateBranchName,
}),
layerServerSettings,
ProviderRegistryMock.layer(options.providers),
options.managedFolders ??
Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
namedProjectsRoot: "/projects",
isScratchProject: () => Effect.succeed(false),
folderForThread: () => Effect.succeedNone,
}),
);
const layerLaunch = ThreadLaunch.layer.pipe(
Layer.provide(
Layer.mergeAll(
layerExternalServices,
layerThreadManagement,
layerReceipts,
IdAllocator.layer,
),
),
);
const layerProjectedProjects = Layer.mock(ProjectStore.ProjectStoreV2)({
get: (requestedProjectId) =>
Effect.succeed(
requestedProjectId === projectId
? Option.some({
projectId,
title: project.title,
workspaceRoot: project.workspaceRoot,
defaultModelSelection: project.defaultModelSelection,
defaultThreadEnvMode: null,
autoPull: false,
faviconPath: null,
projectIcon: null,
scripts: project.scripts,
pinnedAt: null,
archivedAt: null,
createdAt: project.createdAt,
updatedAt: project.updatedAt,
deletedAt: project.deletedAt,
})
: Option.none(),
),
});
const layerTitleRegeneration = ThreadTitleRegeneration.layer.pipe(
Layer.provide(
Layer.mergeAll(
layerThreadManagement,
layerProjectedProjects,
layerExternalServices,
NodeServices.layer,
),
),
);
return {
layer: Layer.mergeAll(
layerLaunch,
layerRegistry,
layerThreadManagement,
layerTitleRegeneration,
layerOutbox,
layerDatabase,
layerExternalServices,
),
createWorktree,
removeWorktree,
deleteLocalBranch,
renameBranch,
generateBranchName,
generateThreadTitle,
runSetup,
closeTerminal,
};
}
function launchInput(input: {
readonly command: string;
readonly thread: string;
readonly message?: string;
readonly workspace?: ThreadLaunch.ThreadLaunchWorkspaceStrategy;
}) {
return {
commandId: CommandId.make(input.command),
threadId: ThreadId.make(input.thread),
projectId,
title: "New thread",
modelSelection,
runtimeMode: "full-access" as const,
interactionMode: "default" as const,
workspaceStrategy: input.workspace ?? { type: "root" as const },
...(input.message === undefined
? {}
: {
initialMessage: {
messageId: MessageId.make(`${input.message}:id`),
text: input.message,
attachments: [],
},
}),
createdBy: "user" as const,
creationSource: "web" as const,
};
}
it.effect.each(
(["new", "existing"] as const).flatMap((target) =>
(["user", "agent"] as const).map((createdBy) => ({ target, createdBy })),
),
)(
"attributes $createdBy-configured automations in $target threads without changing their prompt",
({ target, createdBy }) => {
const harness = makeHarness();
const layerScheduledTasks = ScheduledTasks.layer.pipe(
Layer.provide(
Layer.mergeAll(
harness.layer,
NodeCrypto.layer,
Scheduler.layer,
Layer.mock(SecretRequests.SecretRequests)({}),
ManagedPolicy.layerTest(),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
),
),
);
return Effect.gen(function* () {
const tasks = yield* ScheduledTasks.ScheduledTaskService;
const launches = yield* ThreadLaunch.ThreadLaunchService;
const threads = yield* ThreadManagement.ThreadManagementService;
const existing =
target === "existing"
? yield* launches.launch(
launchInput({ command: "command:existing", thread: "thread:existing" }),
)
: null;
const { task } = yield* tasks.upsert({
id: ScheduledTaskId.make("scheduled-task:attribution"),
title: "Daily audit",
prompt: "Audit performance and crashes.",
enabled: false,
schedule: { type: "interval", everyMs: 60_000 },
projectId,
threadId: existing?.threadId ?? null,
workspaceStrategy: { type: "root" },
modelSelection,
runtimeMode: "full-access",
interactionMode: "default",
createdBy,
creationSource: createdBy === "agent" ? "mcp" : "web",
});
const result = yield* tasks.runNow({ id: task.id });
assert.equal(result.task.lastRunStatus, "succeeded");
const projectThreads = yield* threads.listProjectThreads({
projectId,
includeSubagents: false,
});
const thread =
projectThreads.find((candidate) => candidate.id === existing?.threadId) ??
projectThreads[0];
assert.isDefined(thread);
assert.equal(result.threadId, thread!.id);
const projection = yield* threads.getThreadProjection(thread!.id);
const wire = yield* encodeThreadProjection(projection);
assert.equal(wire.messages[0]?.text, task.prompt);
assert.equal(wire.messages[0]?.scheduledTaskId, task.id);
assert.equal(wire.messages[0]?.createdBy, createdBy);
const turnItem = wire.turnItems.find(
(item): item is Extract<typeof item, { type: "user_message" }> =>
item.type === "user_message",
);
assert.equal(turnItem?.text, task.prompt);
assert.equal(turnItem?.scheduledTaskId, task.id);
}).pipe(Effect.provide(Layer.mergeAll(harness.layer, layerScheduledTasks)));
},
);
it.effect(
"returns no dispatched thread when sending an automation to a missing thread fails",
() => {
const harness = makeHarness();
const layerScheduledTasks = ScheduledTasks.layer.pipe(
Layer.provide(
Layer.mergeAll(
harness.layer,
NodeCrypto.layer,
Scheduler.layer,
Layer.mock(SecretRequests.SecretRequests)({}),
ManagedPolicy.layerTest(),
),
),
);
return Effect.gen(function* () {
const tasks = yield* ScheduledTasks.ScheduledTaskService;
const threadId = ThreadId.make("thread:missing");
const { task } = yield* tasks.upsert({
title: "Daily audit",
prompt: "Audit performance and crashes.",
enabled: false,
schedule: { type: "interval", everyMs: 60_000 },
projectId,
threadId,
workspaceStrategy: { type: "root" },
modelSelection,
runtimeMode: "full-access",
interactionMode: "default",
createdBy: "user",
creationSource: "web",
});
const result = yield* tasks.runNow({ id: task.id });
assert.equal(result.task.lastRunStatus, "failed");
assert.isNull(result.threadId);
assert.equal(result.task.threadId, threadId);
}).pipe(Effect.provide(Layer.mergeAll(harness.layer, layerScheduledTasks)));
},
);
it.effect("runs a thread-bound automation on the provider the thread uses now", () => {
const harness = makeHarness({ adapters: [adapter, claudeAdapter] });
const layerScheduledTasks = ScheduledTasks.layer.pipe(
Layer.provide(
Layer.mergeAll(
harness.layer,
NodeCrypto.layer,
Scheduler.layer,
Layer.mock(SecretRequests.SecretRequests)({}),
ManagedPolicy.layerTest(),
),
),
);
return Effect.gen(function* () {
const tasks = yield* ScheduledTasks.ScheduledTaskService;
const launches = yield* ThreadLaunch.ThreadLaunchService;
const threads = yield* ThreadManagement.ThreadManagementService;
const launched = yield* launches.launch(
launchInput({ command: "command:switched", thread: "thread:switched" }),
);
const { task } = yield* tasks.upsert({
id: ScheduledTaskId.make("scheduled-task:switched"),
title: "Hourly check",
prompt: "Check on the delegated workers.",
enabled: false,
schedule: { type: "interval", everyMs: 3_600_000 },
projectId,
threadId: launched.threadId,
workspaceStrategy: { type: "root" },
modelSelection,
runtimeMode: "full-access",
interactionMode: "default",
createdBy: "agent",
creationSource: "mcp",
});
yield* threads.dispatch({
type: "thread.model-selection.set",
commandId: CommandId.make("command:switch-selection"),
threadId: launched.threadId,
modelSelection: claudeModelSelection,
});
const result = yield* tasks.runNow({ id: task.id });
assert.equal(result.task.lastRunStatus, "succeeded");
const projection = yield* threads.getThreadProjection(launched.threadId);
const message = projection.messages.find((item) => item.scheduledTaskId === task.id);
const run = projection.runs.find((item) => item.id === message?.runId);
assert.deepStrictEqual(run?.modelSelection, claudeModelSelection);
assert.deepStrictEqual(projection.thread.modelSelection, claudeModelSelection);
}).pipe(Effect.provide(Layer.mergeAll(harness.layer, layerScheduledTasks)));
});
it.effect("retains automation and sender attribution while a message waits in the queue", () => {
const harness = makeHarness({ runSetup: () => Effect.never });
return Effect.gen(function* () {
const launches = yield* ThreadLaunch.ThreadLaunchService;
const threads = yield* ThreadManagement.ThreadManagementService;
const launched = yield* launches.launch(
launchInput({
command: "command:automation:queue",
thread: "thread:automation:queue",
message: "First message",
workspace: { type: "worktree", baseRef: "main" },
}),
);
const scheduledTaskId = ScheduledTaskId.make("scheduled-task:queued");
const senderThreadId = ThreadId.make("thread:agent-sender");
const queued = yield* threads.sendToThread({
projectId,
commandId: CommandId.make("command:automation:queued"),
threadId: launched.threadId,
messageId: MessageId.make("message:automation:queued"),
scheduledTaskId,
senderThreadId,
text: "Run the audit",
attachments: [],
mode: "queue",
createdBy: "agent",
creationSource: "mcp",
});
assert.equal(queued.delivery, "queued");
const projection = yield* threads.getThreadProjection(launched.threadId);
const message = projection.messages.find((item) => item.id === queued.message.id);
assert.equal(message?.scheduledTaskId, scheduledTaskId);
assert.equal(message?.senderThreadId, senderThreadId);
assert.equal(message?.text, "Run the audit");
// A fresh send queues instead of steering, so it needs no steerable run.
const fresh = yield* threads.sendToThread({
projectId,
commandId: CommandId.make("command:automation:queued-fresh"),
threadId: launched.threadId,
messageId: MessageId.make("message:automation:queued-fresh"),
text: "Start over",
attachments: [],
mode: "steer",
freshContext: true,
createdBy: "agent",
creationSource: "mcp",
});
assert.equal(fresh.delivery, "queued");
assert.isTrue(fresh.run.freshContext);
}).pipe(Effect.provide(harness.layer));
});
it.effect("provisions independent launches concurrently instead of behind a global semaphore", () =>
Effect.gen(function* () {
const setupCount = yield* Ref.make(0);
const bothEntered = yield* Deferred.make<void>();
const allowSetup = yield* Deferred.make<void>();
const harness = makeHarness({
runSetup: () =>
Ref.updateAndGet(setupCount, (count) => count + 1).pipe(
Effect.tap((count) =>
count === 2 ? Deferred.succeed(bothEntered, undefined) : Effect.void,
),
Effect.andThen(Deferred.await(allowSetup)),
Effect.as({ status: "no-script" as const }),
),
});
yield* Effect.gen(function* () {
const launches = yield* ThreadLaunch.ThreadLaunchService;
const results = yield* Effect.all(
[
launches.launch(
launchInput({
command: "command:launch:concurrent-a",
thread: "thread:launch:concurrent-a",
message: "First",
workspace: { type: "worktree", baseRef: "main" },
}),
),
launches.launch(
launchInput({
command: "command:launch:concurrent-b",
thread: "thread:launch:concurrent-b",
message: "Second",
workspace: { type: "worktree", baseRef: "main" },
}),
),
],
{ concurrency: "unbounded" },
);
assert.deepEqual(
results.map((result) => result.projection.runs[0]?.status),
["preparing", "preparing"],
);
yield* Deferred.await(bothEntered);
assert.equal(yield* Ref.get(setupCount), 2);
yield* Deferred.succeed(allowSetup, undefined);
}).pipe(Effect.provide(harness.layer));
}),
);
it.effect.each([" /COMPACT "])(
"uses the first conversation message for a title after %s",
(nativeCommand) =>
Effect.gen(function* () {
const harness = makeHarness();
yield* Effect.gen(function* () {
const launches = yield* ThreadLaunch.ThreadLaunchService;
const threads = yield* ThreadManagement.ThreadManagementService;
const outbox = yield* EffectOutbox.EffectOutboxV2;
const launched = yield* launches.launch({
...launchInput({
command: "compact-title",
thread: "compact-title-thread",
message: nativeCommand,
}),
generateTitle: true,
});
assert.isUndefined(
(yield* threads.getThreadProjection(launched.threadId)).thread.titleRegeneration,
);
assert.isNull((yield* threads.getThreadProjection(launched.threadId)).thread.lastVisitedAt);
assert.isFalse(
(yield* outbox.listByCommandId(CommandId.make("compact-title:initial-message"))).some(
(effect) => effect.request.type === "thread-title.generate",
),
);
const commandId = CommandId.make("compact-title-conversation");
const messageId = MessageId.make("compact-title-conversation-message");
yield* threads.dispatch({
type: "message.dispatch",
commandId,
threadId: launched.threadId,
messageId,
createdBy: "user",
creationSource: "web",
text: "Fix the failing parser",
attachments: [],
dispatchMode: { type: "defer_start" },
});
assert.equal(
(yield* threads.getThreadProjection(launched.threadId)).thread.titleRegeneration
?.requestId,
commandId,
);
assert.deepEqual(
(yield* outbox.listByCommandId(commandId))
.filter((effect) => effect.request.type === "thread-title.generate")
.map((effect) => effect.request),
[{ type: "thread-title.generate", kind: { type: "initial", messageId } }],
);
}).pipe(Effect.provide(harness.layer));
}),
);
it.effect("keeps native maintenance commands out of steering and restart messages", () =>
Effect.gen(function* () {
const harness = makeHarness();
yield* Effect.gen(function* () {
const launches = yield* ThreadLaunch.ThreadLaunchService;
const threads = yield* ThreadManagement.ThreadManagementService;
const outbox = yield* EffectOutbox.EffectOutboxV2;
for (const scenario of [
{
name: "compact-steer",
first: "Fix the parser",
next: " /COMPACT ",
mode: "steer_active",
},
{
name: "compact-restart",
first: "Fix the parser",
next: "/compact",
mode: "restart_active",
},
{
name: "logout-steer",
first: "Fix the parser",
next: "/logout",
mode: "steer_active",
},
{
name: "logout-restart",
first: "Fix the parser",
next: "/logout",
mode: "restart_active",
},
{
name: "steer-logout",
first: "/logout",
next: "Continue with the parser",
mode: "steer_active",
},
{
name: "steer-compaction",
first: "/compact",
next: "Continue with the parser",
mode: "steer_active",
},
] as const) {
const launched = yield* launches.launch(
launchInput({
command: `${scenario.name}:launch`,
thread: scenario.name,
message: scenario.first,
}),
);
const before = yield* threads.getThreadProjection(launched.threadId);
const targetRun = before.runs[0];
if (targetRun === undefined) return yield* Effect.die("Launch must create a run");
const commandId = CommandId.make(`${scenario.name}:message`);
const dispatch = threads.dispatch({
type: "message.dispatch",
commandId,
threadId: launched.threadId,
messageId: MessageId.make(`${scenario.name}:message`),
createdBy: "user",
creationSource: "web",
text: scenario.next,
attachments: [],
dispatchMode: { type: scenario.mode, targetRunId: targetRun.id },
});
if (scenario.name.startsWith("steer-")) {
yield* dispatch;
const queued = (yield* threads.getThreadProjection(launched.threadId)).runs[1];
assert.equal(queued?.status, "queued");
assert.equal(queued?.userMessageId, MessageId.make(`${scenario.name}:message`));
continue;
}
const failure = yield* dispatch.pipe(Effect.flip);
assert.include(
String(failure.cause).toLowerCase(),
scenario.name.includes("logout") ? "sign" : "context compaction",
);
const after = yield* threads.getThreadProjection(launched.threadId);
assert.deepEqual(after.messages, before.messages);
assert.deepEqual(after.thread.titleRegeneration, before.thread.titleRegeneration);
assert.deepEqual(yield* outbox.listByCommandId(commandId), []);
}
}).pipe(Effect.provide(harness.layer));
}),
);
it.effect("arms durable title generation after accepting the first message", () =>
Effect.gen(function* () {
const harness = makeHarness({
generateTitle: (input) =>
Effect.succeed({
title: input.previousTitle === undefined ? "Generated title" : "Regenerated title",
}),
});
yield* Effect.gen(function* () {
const launches = yield* ThreadLaunch.ThreadLaunchService;
const threads = yield* ThreadManagement.ThreadManagementService;
const outbox = yield* EffectOutbox.EffectOutboxV2;
const titleRegeneration = yield* ThreadTitleRegeneration.ThreadTitleRegenerationService;
const input = {
...launchInput({
command: "command:launch:title-generation",
thread: "thread:launch:title-generation",
message: "Generate my title",
}),
title: "Generate my title",
generateTitle: true,
};
const launched = yield* launches.launch(input);
const generationCommandId = CommandId.make("command:launch:title-generation:initial-message");
const projection = yield* threads.getThreadProjection(launched.threadId);
assert.equal(projection.thread.title, "Generate my title");
assert.equal(projection.thread.titleRegeneration?.requestId, generationCommandId);
assert.deepEqual(
(yield* outbox.listByCommandId(generationCommandId)).map((effect) => effect.request),
[
{
type: "thread-title.generate",
kind: { type: "initial", messageId: MessageId.make("Generate my title:id") },
},
],
);
yield* titleRegeneration.execute({
threadId: launched.threadId,
requestId: generationCommandId,
kind: { type: "initial", messageId: MessageId.make("Generate my title:id") },
});
const generated = yield* threads.getThreadProjection(launched.threadId);
assert.equal(generated.thread.title, "Generated title");
assert.deepEqual(
harness.generateThreadTitle.mock.calls[0]?.[0]?.modelSelection,
DEFAULT_SERVER_SETTINGS.textGenerationModelSelection,
);
const manualRequestId = CommandId.make("command:title-generation:manual");
yield* threads.dispatch({
type: "thread.metadata.update",
commandId: manualRequestId,
threadId: launched.threadId,
regenerateTitle: true,
});
assert.deepEqual(
(yield* outbox.listByCommandId(manualRequestId)).map((effect) => effect.request),
[{ type: "thread-title.generate", kind: { type: "regenerate" } }],
);
yield* titleRegeneration.execute({
threadId: launched.threadId,
requestId: manualRequestId,
kind: { type: "regenerate" },
});
const regenerated = yield* threads.getThreadProjection(launched.threadId);
assert.equal(regenerated.thread.title, "Regenerated title");
assert.equal(
harness.generateThreadTitle.mock.calls[1]?.[0]?.previousTitle,
"Generated title",
);
yield* threads.dispatch({
type: "thread.metadata.update",
commandId: CommandId.make("command:title-generation:user-rename"),
threadId: launched.threadId,
title: "Keep my title",
});
const renamed = yield* threads.getThreadProjection(launched.threadId);
yield* TestClock.adjust(Duration.seconds(1));
yield* threads.dispatch({
type: "thread.title.regeneration.complete",
commandId: CommandId.make("command:title-generation:stale-completion"),
threadId: launched.threadId,
requestId: generationCommandId,
title: "Stale generated title",
});
const afterStaleCompletion = yield* threads.getThreadProjection(launched.threadId);
assert.equal(afterStaleCompletion.thread.title, "Keep my title");
assert.equal(
DateTime.toEpochMillis(afterStaleCompletion.thread.updatedAt),
DateTime.toEpochMillis(renamed.thread.updatedAt),
);
}).pipe(Effect.provide(harness.layer));
}),
);
it.effect("does not update a reused thread title when the initial message is rejected", () =>
Effect.gen(function* () {
const harness = makeHarness();
yield* Effect.gen(function* () {
const launches = yield* ThreadLaunch.ThreadLaunchService;
const threads = yield* ThreadManagement.ThreadManagementService;
const outbox = yield* EffectOutbox.EffectOutboxV2;
const threadId = ThreadId.make("thread:launch:reused-title-failure");
yield* threads.dispatch({
type: "thread.create",
commandId: CommandId.make("command:launch:reused-title-failure:create"),
threadId,
projectId,
title: "Original title",
modelSelection,
runtimeMode: "full-access",
interactionMode: "default",
branch: null,
worktreePath: null,
createdBy: "user",
creationSource: "web",
});
const commandId = CommandId.make("command:launch:reused-title-failure");
const failed = yield* launches
.launch({
...launchInput({
command: commandId,
thread: threadId,
message: "Generate a provisional title",
}),
reuseExistingThread: true,
title: "Generate a provisional title",
generateTitle: true,
modelSelection: {
instanceId: ProviderInstanceId.make("missing-provider"),
model: "missing-model",
},
})
.pipe(Effect.exit);
assert.isTrue(Exit.isFailure(failed));
const projection = yield* threads.getThreadProjection(threadId);
assert.equal(projection.thread.title, "Original title");
assert.isUndefined(projection.thread.titleRegeneration);
assert.isEmpty(projection.messages);
assert.isEmpty(yield* outbox.listByCommandId(CommandId.make(`${commandId}:initial-message`)));
}).pipe(Effect.provide(harness.layer));
}),
);
// Stands `projectId` in for the Scratch project: a plain folder, not a Git
// repository, so Git fails there with the error a real one raises.
function scratchHarness() {
const claimed: Array<ThreadId> = [];
const scratchRoot = project.workspaceRoot;
const notARepository = (operation: string, cwd: string) =>
new GitCommandError({
operation,
command: "vcs-route",
cwd,
detail: "Failed to resolve the VCS driver for this Git command.",
});
const harness = makeHarness({
managedFolders: Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
namedProjectsRoot: "/projects",
isScratchProject: (id) => Effect.succeed(id === projectId),
folderForThread: (input) =>
Effect.sync(() => {
if (input.projectId !== projectId) return Option.none();
claimed.push(input.threadId);
return Option.some(`/scratch/folder-${claimed.length}`);
}),
}),
remoteExists: (input) =>
input.cwd === scratchRoot
? Effect.fail(notARepository("GitWorkflowService.remoteExists", input.cwd))
: Effect.succeed(true),
createWorktree: (input) =>
input.cwd === scratchRoot
? Effect.fail(notARepository("GitWorkflowService.createWorktree", input.cwd))
: Effect.succeed({
worktree: {
path: "/other-repo-worktrees/feature",
refName: input.newRefName,
headSha: "abc",
},
} as never),
});
const layerScheduledTasks = ScheduledTasks.layer.pipe(
Layer.provide(
Layer.mergeAll(
harness.layer,
NodeCrypto.layer,
Scheduler.layer,
Layer.mock(SecretRequests.SecretRequests)({}),
ManagedPolicy.layerTest(),
),
),
);
return {
...harness,
claimed,
layer: Layer.mergeAll(harness.layer, layerScheduledTasks),
};
}
const worktreeStrategy = { type: "worktree", baseRef: "main", startFromOrigin: true } as const;
/** Settles once preparation releases the run, or fails it. */
const preparationSettled = (threadId: ThreadId) =>
Effect.gen(function* () {
const threads = yield* ThreadManagement.ThreadManagementService;
yield* threads.streamStoredEventsFrom({ threadId }).pipe(
Stream.filter(
(stored) =>
stored.event.type === "run.updated" &&
(stored.commandId?.endsWith(":release") === true ||
stored.event.payload.status === "failed"),
),
Stream.runHead,
);
return yield* threads.getThreadProjection(threadId);
});
function scheduledTaskInput(id: string, targetProjectId: ProjectId) {
return {
id: ScheduledTaskId.make(id),
title: "Daily summary",
prompt: "Summarize the day.",
enabled: false,
schedule: { type: "interval" as const, everyMs: 60_000 },
projectId: targetProjectId,
threadId: null,
workspaceStrategy: worktreeStrategy,
modelSelection,
runtimeMode: "full-access" as const,
interactionMode: "default" as const,
};
}
it.effect("launches a worktree request for Scratch at the root, in its own folder", () => {
const harness = scratchHarness();
return Effect.gen(function* () {
const launches = yield* ThreadLaunch.ThreadLaunchService;
const launched = yield* launches.launch(
launchInput({
command: "command:launch:scratch-worktree",
thread: "thread:launch:scratch-worktree",
message: "Tidy my notes",
workspace: worktreeStrategy,
}),
);
const scratch = yield* preparationSettled(launched.threadId);
assert.equal(scratch.thread.worktreePath, "/scratch/folder-1");
// Released past preparation; provider execution is disabled here.
assert.equal(scratch.runs[0]?.status, "starting");
assert.deepEqual(scratch.runs[0]?.workspacePreparation, {
type: "existing_worktree",
worktreePath: "/scratch/folder-1",
});
assert.equal(harness.runSetup.mock.calls[0]?.[0]?.worktreePath, "/scratch/folder-1");
assert.equal(harness.createWorktree.mock.calls.length, 0);
// A Git project still gets the worktree it asked for.
const other = yield* launches.launch({
...launchInput({
command: "command:launch:git-worktree",
thread: "thread:launch:git-worktree",
message: "Build the feature",
workspace: worktreeStrategy,
}),
projectId: otherProjectId,
});
const git = yield* preparationSettled(other.threadId);
assert.equal(git.runs[0]?.status, "starting");
assert.equal(git.runs[0]?.workspacePreparation?.type, "worktree");
assert.equal(git.thread.worktreePath, "/other-repo-worktrees/feature");
assert.equal(harness.createWorktree.mock.calls[0]?.[0]?.cwd, "/other-repo");
assert.deepEqual(harness.claimed, [launched.threadId]);
}).pipe(Effect.provide(harness.layer));
});
it.effect("stores a Scratch scheduled task at the root and keeps worktrees elsewhere", () => {
const harness = scratchHarness();
return Effect.gen(function* () {
const tasks = yield* ScheduledTasks.ScheduledTaskService;
const scratch = yield* tasks.upsert(
scheduledTaskInput("scheduled-task:scratch-upsert", projectId),
);
assert.deepEqual(scratch.task.workspaceStrategy, { type: "root" });
const git = yield* tasks.upsert(
scheduledTaskInput("scheduled-task:git-upsert", otherProjectId),
);
assert.deepEqual(git.task.workspaceStrategy, worktreeStrategy);
}).pipe(Effect.provide(harness.layer));
});
it.effect("runs a Scratch scheduled task saved with a worktree in its own folder", () => {
const harness = scratchHarness();
return Effect.gen(function* () {
const tasks = yield* ScheduledTasks.ScheduledTaskService;
const threads = yield* ThreadManagement.ThreadManagementService;
const sql = yield* SqlClient.SqlClient;
const { task } = yield* tasks.upsert(
scheduledTaskInput("scheduled-task:scratch-stored", projectId),
);
// Tasks saved before Scratch was coerced still hold a worktree strategy.
yield* sql`
UPDATE scheduled_tasks
SET workspace_strategy_json = ${JSON.stringify(worktreeStrategy)}
WHERE task_id = ${task.id}
`;
const ran = yield* tasks.runNow({ id: task.id });
assert.equal(ran.task.lastRunStatus, "succeeded");
const [thread] = yield* threads.listProjectThreads({ projectId, includeSubagents: false });
assert.isDefined(thread);
const projection = yield* preparationSettled(thread!.id);
assert.equal(projection.runs[0]?.status, "starting");
assert.equal(projection.thread.worktreePath, "/scratch/folder-1");
assert.deepEqual(projection.runs[0]?.workspacePreparation, {
type: "existing_worktree",
worktreePath: "/scratch/folder-1",
});
assert.equal(harness.runSetup.mock.calls[0]?.[0]?.worktreePath, "/scratch/folder-1");
assert.equal(harness.createWorktree.mock.calls.length, 0);
}).pipe(Effect.provide(harness.layer));
});
it.effect.each(["stable", "upstream/release"])(
"launches from %s with the fetched commit and remote PR base",
(baseRef) =>
Effect.gen(function* () {
const fs = yield* FileSystem.FileSystem;
const git = yield* GitVcsDriver.GitVcsDriver;
const directory = yield* fs.makeTempDirectoryScoped({ prefix: "launch-remote-base-" });
const cwd = `${directory}/repo`;
const remote = `${directory}/remote.git`;
const worktreePath = `${directory}/worktree`;
yield* fs.makeDirectory(cwd);
const command = (at: string, args: string[]) =>
git.execute({ operation: "launch-test", cwd: at, args });
yield* command(cwd, ["init", "-b", "stable"]);
yield* command(cwd, ["config", "user.name", "Test"]);
yield* command(cwd, ["config", "user.email", "test@example.test"]);
yield* command(cwd, ["commit", "--allow-empty", "-m", "initial"]);
const localHead = (yield* command(cwd, ["rev-parse", "HEAD"])).stdout.trim();
yield* command(cwd, ["init", "--bare", remote]);
yield* command(cwd, ["remote", "add", "upstream", remote]);
yield* command(cwd, ["push", "-u", "upstream", "stable:release"]);
yield* command(cwd, ["commit", "--allow-empty", "-m", "remote advance"]);
yield* command(cwd, ["push", "upstream", "stable:release"]);
const remoteHead = (yield* command(cwd, ["rev-parse", "HEAD"])).stdout.trim();
yield* command(cwd, ["reset", "--hard", localHead]);
yield* command(cwd, ["update-ref", "-d", "refs/remotes/upstream/release"]);
const setupStarted = yield* Deferred.make<void>();
const harness = makeHarness({
hasCommit: ({ refName }) =>
command(cwd, ["rev-parse", "--verify", `${refName}^{commit}`]).pipe(
Effect.as(true),
Effect.orElseSucceed(() => false),
),
git: {
resolveWorktreeBaseRemote: (input) => git.resolveWorktreeBaseRemote({ ...input, cwd }),
hasRefNamed: () => Effect.succeed(false),
},
fetchWorktreeBaseCommit: (input) => git.fetchWorktreeBaseCommit({ ...input, cwd }),
createWorktree: (input, options) =>
git.createWorktree({ ...input, cwd, path: worktreePath }, options),
runSetup: () =>
Deferred.succeed(setupStarted, undefined).pipe(
Effect.as({ status: "no-script" as const }),
),
});
yield* Effect.gen(function* () {
const launches = yield* ThreadLaunch.ThreadLaunchService;
const threads = yield* ThreadManagement.ThreadManagementService;
const workspace = {
type: "worktree" as const,
baseRef,
branch: "feature",
startFromOrigin: true,
};
yield* launches.checkWorktreeBase({ projectId, workspaceStrategy: workspace });
const launched = yield* launches.launch(
launchInput({
command: "command:launch:remote-base",
thread: "thread:launch:remote-base",
workspace,
}),
);
yield* Deferred.await(setupStarted);
const projection = yield* threads.getThreadProjection(launched.threadId);
assert.equal(projection.thread.worktreePath, worktreePath);
assert.equal(
(yield* command(worktreePath, ["rev-parse", "HEAD"])).stdout.trim(),
remoteHead,
);
const preview = yield* git.getReviewDiffPreview({ cwd: worktreePath });
const comparisonBase = preview.sources.find(
(source) => source.kind === "branch-range",
)!.baseRef;
assert.equal(
(yield* command(worktreePath, ["rev-parse", `${comparisonBase}^{commit}`])).stdout.trim(),
remoteHead,
);
}).pipe(Effect.provide(harness.layer));
}).pipe(
Effect.provide(
GitVcsDriver.layer.pipe(
Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "launch-remote-git-" })),
Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
),
),
),
);
it.effect("fetches the origin base from the remote it already resolved", () => {
let fetchInput: Deferred.Deferred<unknown> | null = null;
const harness = makeHarness({
fetchWorktreeBaseCommit: (input) => Deferred.succeed(fetchInput!, input).pipe(Effect.as(null)),
});
return Effect.gen(function* () {
fetchInput = yield* Deferred.make<unknown>();
const launches = yield* ThreadLaunch.ThreadLaunchService;
yield* launches.launch(
launchInput({
command: "command:launch:resolved-remote",
thread: "thread:launch:resolved-remote",
workspace: { type: "worktree", baseRef: "main", startFromOrigin: true },
}),
);
assert.deepEqual(yield* Deferred.await(fetchInput), {
cwd: project.workspaceRoot,
refName: "main",
remote: { remoteName: "origin", branchName: "main" },
});
}).pipe(Effect.provide(harness.layer));
});
it.effect("shows the fetch diagnosis when preparing a worktree from origin fails", () => {
const detail =
"Git could not authenticate with the remote. Check Git credentials or SSH access on the server, then retry.";
const harness = makeHarness({
fetchWorktreeBaseCommit: () =>
Effect.fail(
new GitCommandError({
operation: "GitVcsDriver.fetchRemote",
command: "git",
cwd: project.workspaceRoot,
detail,
exitCode: 128,
}),
),
});
return Effect.gen(function* () {
const launches = yield* ThreadLaunch.ThreadLaunchService;
const threads = yield* ThreadManagement.ThreadManagementService;
const launched = yield* launches.launch(
launchInput({
command: "command:launch:fetch-failure",
thread: "thread:launch:fetch-failure",
message: "Start from origin",
workspace: { type: "worktree", baseRef: "main", startFromOrigin: true },
}),
);
yield* threads.streamStoredEventsFrom({ threadId: launched.threadId }).pipe(
Stream.filter(
(stored) => stored.event.type === "run.updated" && stored.event.payload.status === "failed",
),
Stream.runHead,
);
const projection = yield* threads.getThreadProjection(launched.threadId);
assert.equal(projection.messages[0]?.text, "Start from origin");
assert.equal(projection.runs[0]?.status, "failed");
assert.equal(projection.thread.worktreePath, null);
assert.equal(
projection.turnItems.find((item) => item.type === "command_execution")?.status,
"failed",
);
assert.include(
projection.turnItems.find((item) => item.type === "error")?.failure.message ?? "",
detail,
);
assert.equal(harness.createWorktree.mock.calls.length, 0);
assert.equal(harness.runSetup.mock.calls.length, 0);
}).pipe(Effect.provide(harness.layer));
});
it.effect("rejects a preparation retry after the project disables its provider", () => {
let fetchAttempts = 0;
const harness = makeHarness({
fetchWorktreeBaseCommit: () =>
fetchAttempts++ === 0
? Effect.fail(
new GitCommandError({
operation: "GitVcsDriver.fetchRemote",
command: "git",
cwd: project.workspaceRoot,
detail: "Git could not reach the remote.",
exitCode: 128,
}),
)
: Effect.succeed({ commitSha: "remote-main-sha", remoteRefName: "origin/main" }),
});
return Effect.gen(function* () {
const launches = yield* ThreadLaunch.ThreadLaunchService;
const settings = yield* ServerSettings.ServerSettingsService;
const threads = yield* ThreadManagement.ThreadManagementService;
const launched = yield* launches.launch(
launchInput({
command: "command:launch:disabled-preparation-retry",
thread: "thread:launch:disabled-preparation-retry",
message: "Start from origin",
workspace: { type: "worktree", baseRef: "main", startFromOrigin: true },
}),
);
yield* preparationSettled(launched.threadId);
yield* settings.updateSettings({
projectSettingsOverrides: {
[projectId]: { providerInstances: { [modelSelection.instanceId]: { enabled: false } } },
},
});
const error = yield* launches
.retryPreparation({
commandId: CommandId.make("command:launch:disabled-preparation-retry:retry"),
threadId: launched.threadId,
runId: launched.projection.runs[0]!.id,
})
.pipe(Effect.flip);
assert.equal(error._tag, "ThreadManagementProviderInstanceDisabledError");
assert.equal((yield* threads.getThreadProjection(launched.threadId)).runs[0]?.status, "failed");
assert.equal(fetchAttempts, 1);
}).pipe(Effect.provide(harness.layer));
});
it.effect("does not release a prepared run after the project disables its provider", () => {
return Effect.gen(function* () {
const setupEntered = yield* Deferred.make<void>();
const allowSetup = yield* Deferred.make<void>();
const harness = makeHarness({
runSetup: () =>
Deferred.succeed(setupEntered, undefined).pipe(
Effect.andThen(Deferred.await(allowSetup)),
Effect.as({ status: "no-script" as const }),
),
});
yield* Effect.gen(function* () {
const launches = yield* ThreadLaunch.ThreadLaunchService;
const settings = yield* ServerSettings.ServerSettingsService;
const launched = yield* launches.launch(
launchInput({
command: "command:launch:disable-during-preparation",
thread: "thread:launch:disable-during-preparation",
message: "Prepare a worktree",
workspace: { type: "worktree", baseRef: "main" },
}),
);
yield* Deferred.await(setupEntered);
yield* settings.updateSettings({
projectSettingsOverrides: {
[projectId]: { providerInstances: { [modelSelection.instanceId]: { enabled: false } } },
},
});
yield* Deferred.succeed(allowSetup, undefined);
const projection = yield* preparationSettled(launched.threadId);
assert.equal(projection.runs[0]?.status, "failed");
const effects = yield* (yield* EffectOutbox.EffectOutboxV2).listByCommandId(
CommandId.make("command:launch:disable-during-preparation:release"),
);
assert.isFalse(
effects.some(
(effect) =>
effect.request.type === "provider-turn.start" &&
effect.request.runId === launched.projection.runs[0]?.id,
),
);
}).pipe(Effect.provide(harness.layer));
});
});
it.effect.each(["fails", "is interrupted"] as const)(
"holds a message queued during setup when the workspace preparation %s",
(ending) =>
Effect.gen(function* () {
const fetchEntered = yield* Deferred.make<void>();
const allowFetch = yield* Deferred.make<void>();
let fetchFailures = 1;
const harness = makeHarness({
fetchWorktreeBaseCommit: () =>
fetchFailures-- <= 0
? Effect.succeed({ commitSha: "remote-main-sha", remoteRefName: "origin/main" })
: Deferred.succeed(fetchEntered, undefined).pipe(
Effect.andThen(Deferred.await(allowFetch)),
Effect.andThen(
Effect.fail(
new GitCommandError({
operation: "GitVcsDriver.fetchRemote",
command: "git",
cwd: project.workspaceRoot,
detail: "Git could not reach the remote.",
exitCode: 128,
}),
),
),
),
});
yield* Effect.gen(function* () {
const launches = yield* ThreadLaunch.ThreadLaunchService;
const threads = yield* ThreadManagement.ThreadManagementService;
const launched = yield* launches.launch(
launchInput({
command: `command:launch:queued-setup-${ending}`,
thread: `thread:launch:queued-setup-${ending}`,
message: "First message",
workspace: { type: "worktree", baseRef: "main", startFromOrigin: true },
}),
);
yield* Deferred.await(fetchEntered);
const queued = yield* threads.sendToThread({
projectId,
commandId: CommandId.make(`command:launch:queued-setup-${ending}:follow-up`),
threadId: launched.threadId,
messageId: MessageId.make(`message:launch:queued-setup-${ending}:follow-up`),
text: "Sent during setup",
attachments: [],
mode: "queue",
createdBy: "user",
creationSource: "web",
});
assert.equal(queued.delivery, "queued");
if (ending === "fails") {
yield* Deferred.succeed(allowFetch, undefined);
} else {
yield* threads.dispatch({
type: "run.interrupt",
commandId: CommandId.make("command:launch:queued-setup-interrupt"),
threadId: launched.threadId,
runId: launched.projection.runs[0]!.id,
});
}
yield* threads.streamStoredEventsFrom({ threadId: launched.threadId }).pipe(
Stream.filter(
(stored) =>
stored.event.type === "run.updated" && stored.event.payload.queueHeld === true,
),
Stream.runHead,
);
const projection = yield* threads.getThreadProjection(launched.threadId);
assert.equal(projection.runs.at(-1)?.status, "queued");
assert.equal(projection.thread.worktreePath, null);
if (ending === "fails") {
yield* launches.retryPreparation({
commandId: CommandId.make("command:launch:queued-setup-retry"),
threadId: launched.threadId,
runId: launched.projection.runs[0]!.id,
});
const retried = yield* threads.getThreadProjection(launched.threadId);
assert.equal(retried.runs.at(-1)?.queueHeld, false);
}
}).pipe(Effect.provide(harness.layer));
}),
);
it.effect.each(["failed", "interrupted"] as const)(
"holds a message queued during setup that arrives after the setup %s",
(ending) => {
let fetchEntered: Deferred.Deferred<void> | null = null;
const harness = makeHarness({
fetchWorktreeBaseCommit: () =>
ending === "interrupted"
? Deferred.succeed(fetchEntered!, undefined).pipe(Effect.andThen(Effect.never))
: Effect.fail(
new GitCommandError({
operation: "GitVcsDriver.fetchRemote",
command: "git",
cwd: project.workspaceRoot,
detail: "Git could not reach the remote.",
exitCode: 128,
}),
),
});
return Effect.gen(function* () {
fetchEntered = yield* Deferred.make<void>();
const launches = yield* ThreadLaunch.ThreadLaunchService;
const threads = yield* ThreadManagement.ThreadManagementService;
const launched = yield* launches.launch(
launchInput({
command: `command:launch:late-queued-follow-up-${ending}`,
thread: `thread:launch:late-queued-follow-up-${ending}`,
message: "First message",
workspace: { type: "worktree", baseRef: "main", startFromOrigin: true },
}),
);
if (ending === "interrupted") {
yield* Deferred.await(fetchEntered);
yield* threads.dispatch({
type: "run.interrupt",
commandId: CommandId.make("command:launch:late-queued-follow-up:interrupt"),
threadId: launched.threadId,
runId: launched.projection.runs[0]!.id,
});
}
yield* threads.streamStoredEventsFrom({ threadId: launched.threadId }).pipe(
Stream.filter(
(stored) => stored.event.type === "run.updated" && stored.event.payload.status === ending,
),
Stream.runHead,
);
const queued = yield* threads.sendToThread({
projectId,
commandId: CommandId.make(`command:launch:late-queued-follow-up-${ending}:send`),
threadId: launched.threadId,
messageId: MessageId.make(`message:launch:late-queued-follow-up-${ending}:send`),
text: "Sent during setup",
attachments: [],
mode: "queue",
createdBy: "user",
creationSource: "web",
});
assert.equal(queued.delivery, "queued");
const projection = yield* threads.getThreadProjection(launched.threadId);
const held = projection.runs.at(-1)!;
assert.equal(held.status, "queued");
assert.equal(held.queueHeld, true);
// A message the user starts does not release it: the held message would
// run after it in the project checkout.
yield* threads.sendToThread({
projectId,
commandId: CommandId.make(`command:launch:late-queued-follow-up-${ending}:start`),
threadId: launched.threadId,
messageId: MessageId.make(`message:launch:late-queued-follow-up-${ending}:start`),
text: "Sent after setup",
attachments: [],
mode: "auto",
createdBy: "user",
creationSource: "web",
});
yield* threads.dispatch({
type: "message.dispatch",
commandId: CommandId.make(`command:launch:late-queued-follow-up-${ending}:wake`),
threadId: launched.threadId,
messageId: MessageId.make(`message:launch:late-queued-follow-up-${ending}:wake`),
text: "Background task completed.",
attachments: [],
dispatchMode: { type: "queue_after_active" },
createdBy: "agent",
creationSource: "provider",
});
const wake = (yield* threads.getThreadProjection(launched.threadId)).runs.at(-1)!;
assert.equal(wake.status, "queued");
assert.isTrue(wake.queueHeld);
// Nor does the next one, though the run that message started is now the
// latest and carries no workspace preparation.
yield* threads.sendToThread({
projectId,
commandId: CommandId.make(`command:launch:late-queued-follow-up-${ending}:again`),
threadId: launched.threadId,
messageId: MessageId.make(`message:launch:late-queued-follow-up-${ending}:again`),
text: "Sent after that",
attachments: [],
mode: "auto",
createdBy: "user",
creationSource: "web",
});
const after = yield* threads.getThreadProjection(launched.threadId);
assert.isTrue(after.runs.find((run) => run.id === held.id)?.queueHeld);
}).pipe(Effect.provide(harness.layer));
},
);
it.effect("replays a server-allocated launch", () =>
Effect.gen(function* () {
const setupEntered = yield* Deferred.make<void>();
const allowSetup = yield* Deferred.make<void>();
const harness = makeHarness({
runSetup: () =>
Deferred.succeed(setupEntered, undefined).pipe(
Effect.andThen(Deferred.await(allowSetup)),
Effect.as({ status: "no-script" as const }),
),
});
yield* Effect.gen(function* () {
const launches = yield* ThreadLaunch.ThreadLaunchService;
const threads = yield* ThreadManagement.ThreadManagementService;
const { threadId: _unusedThreadId, ...rest } = launchInput({
command: "command:launch:allocated-retry",
thread: "unused",
message: "Only once",
workspace: { type: "worktree", baseRef: "main" },
});
const first = yield* launches.launch(rest);
yield* Deferred.await(setupEntered);
const retry = yield* launches.launch(rest);
assert.equal(first.threadId, retry.threadId);
assert.isFalse(first.resumed);
assert.isTrue(retry.resumed);
// Clients drop their pending copy once the thread reaches the message's commit.
assert.isNumber(first.sequence);
assert.equal(retry.sequence, first.sequence);
assert.equal(harness.runSetup.mock.calls.length, 1);
assert.equal(retry.projection.messages.length, 1);
assert.equal(retry.projection.runs.length, 1);
assert.equal(retry.projection.messages[0]?.id, first.projection.messages[0]?.id);
assert.equal(retry.projection.runs[0]?.id, first.projection.runs[0]?.id);
yield* Deferred.succeed(allowSetup, undefined);
yield* threads.streamStoredEventsFrom({ threadId: first.threadId }).pipe(
Stream.filter(
(stored) =>
stored.commandId === CommandId.make(`${rest.commandId}:release`) &&
stored.event.type === "run.updated",
),
Stream.runHead,
);
const settled = yield* launches.launch(rest);
assert.equal(settled.threadId, first.threadId);
assert.isTrue(settled.resumed);
assert.equal(settled.projection.messages[0]?.id, first.projection.messages[0]?.id);
assert.equal(settled.projection.runs[0]?.id, first.projection.runs[0]?.id);
assert.equal(harness.runSetup.mock.calls.length, 1);
}).pipe(Effect.provide(harness.layer));
}),
);
it.effect("replays an accepted launch after the project disables the instance", () => {
const harness = makeHarness();
return Effect.gen(function* () {
const launches = yield* ThreadLaunch.ThreadLaunchService;
const settings = yield* ServerSettings.ServerSettingsService;
const input = launchInput({
command: "command:launch:retry-after-disable",
thread: "thread:launch:retry-after-disable",
message: "Hello",
});
const first = yield* launches.launch(input);
yield* settings.updateSettings({
projectSettingsOverrides: {
[projectId]: { providerInstances: { [modelSelection.instanceId]: { enabled: false } } },
},
});
const retry = yield* launches.launch(input);
assert.equal(retry.threadId, first.threadId);
assert.isTrue(retry.resumed);
const fresh = yield* launches
.launch(
launchInput({
command: "command:launch:fresh-after-disable",
thread: "thread:launch:fresh-after-disable",
message: "Hello",
}),
)
.pipe(Effect.flip);
if (fresh._tag !== "ThreadManagementProviderInstanceDisabledError") {
assert.fail(`expected ThreadManagementProviderInstanceDisabledError, got ${fresh._tag}`);
}
}).pipe(Effect.provide(harness.layer));
});
it.effect("an agent's launch never starts work above the modes it asks for", () => {
const harness = makeHarness();
return Effect.gen(function* () {
const launches = yield* ThreadLaunch.ThreadLaunchService;
const threads = yield* ThreadManagement.ThreadManagementService;
// The first launch, at full access, creates the thread without a message.
const created = yield* launches.launch(
launchInput({ command: "command:launch:narrowed-retry", thread: "thread:narrowed" }),
);
// The same key comes back from a narrower agent, now carrying a message,
// as a retry or a concurrent launch that lost the create would.
const failed = yield* launches
.launch({
...launchInput({
command: "command:launch:narrowed-retry",
thread: "thread:narrowed",
message: "Run this",
}),
runtimeMode: "approval-required",
interactionMode: "plan",
createdBy: "agent",
creationSource: "mcp",
})
.pipe(Effect.flip);
if (failed._tag !== "ThreadLaunchError") {
assert.fail(`expected ThreadLaunchError, got ${failed._tag}`);
}
assert.equal(failed.operation, "dispatch-message");
const projection = yield* threads.getThreadProjection(created.threadId);
assert.equal(projection.runs.length, 0);
assert.equal(projection.messages.length, 0);
}).pipe(Effect.provide(harness.layer));
});
it.effect("rejects a server-allocated launch replay with a mismatching thread id", () => {
const harness = makeHarness();
return Effect.gen(function* () {
const launches = yield* ThreadLaunch.ThreadLaunchService;
const { threadId: _unusedThreadId, ...rest } = launchInput({
command: "command:launch:allocated-mismatch",
thread: "unused",