@@ -16,6 +16,7 @@ import {
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { expect, it } from "vite-plus/test";
@@ -708,3 +709,57 @@ it("readThread returns canonical speech with bounded text continuation and no ex
     ).toBe(true);
   }).pipe(Effect.provide(layer), Effect.runPromise);
 });
+
+it("scheduleTask from an MCP client uses the environment default model when the project has none", async () => {
+  const globalDefault = {
+    instanceId: ProviderInstanceId.make("claudeAgent"),
+    model: "claude-haiku",
+  };
+  const upserted: Array<unknown> = [];
+  const layer = layerOrchestratorService.pipe(
+    Layer.provide(
+      Layer.mergeAll(
+        unusedDelegationPolicyLayer,
+        ServerSettings.layerTest({ defaultModelSelection: globalDefault }),
+        Layer.mock(ThreadManagementService.ThreadManagementService)({}),
+        Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
+        Layer.mock(ProjectService.ProjectService)({
+          getById: () =>
+            Effect.succeed(Option.some({ id: projectId, defaultModelSelection: null } as never)),
+        }),
+        Layer.mock(SecretRequests.SecretRequests)({}),
+        Layer.mock(RemoteDelegation.RemoteDelegation)({}),
+        Layer.mock(ScheduledTaskService.ScheduledTaskService)({
+          upsert: (input) =>
+            Effect.sync(() => upserted.push(input.modelSelection)).pipe(
+              Effect.andThen(Effect.die("upsert recorded")),
+            ),
+        }),
+        Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
+          list: () => Effect.succeed([]),
+        }),
+        NodeCrypto.layer,
+      ),
+    ),
+  );
+
+  await Effect.gen(function* () {
+    const service = yield* OrchestratorMcpService.OrchestratorMcpService;
+    yield* service
+      .scheduleTask(
+        {
+          ...makeScope(),
+          thread: undefined,
+          client: { sessionId: "session-1", label: "Claude Code", access: "auto" },
+        },
+        {
+          projectId,
+          prompt: "check in later",
+          enabled: false,
+          schedule: { type: "interval", everyMs: 3_600_000 },
+        },
+      )
+      .pipe(Effect.exit);
+    expect(upserted).toEqual([globalDefault]);
+  }).pipe(Effect.provide(layer), Effect.runPromise);
+});
@@ -65,6 +65,7 @@ import {
 } from "@t3tools/contracts";
 import { getProviderOptionCurrentValue } from "@t3tools/shared/model";
 import { runRanAfter } from "@t3tools/shared/orchestrationV2ThreadError";
+import { resolveProjectSettings } from "@t3tools/shared/projectSettings";
 import { formatThreadLink } from "@t3tools/shared/threadLinks";
 import {
   normalizeThreadPullRequestKey,
@@ -1024,17 +1025,25 @@ const make = Effect.gen(function* () {
       ),
     );
 
-  const projectDefaultModelSelection = (
-    project: Effect.Success<ReturnType<typeof requireProject>>,
-  ) =>
-    project.defaultModelSelection === null
-      ? Effect.fail(
-          failure(
-            "invalid_request",
-            `Project ${project.id} has no default model, so this caller cannot pick one for it.`,
-          ),
-        )
-      : Effect.succeed(project.defaultModelSelection);
+  /** The project's effective default: project override, then the environment default. */
+  const projectDefaultModelSelection = Effect.fn(
+    "OrchestratorMcpService.projectDefaultModelSelection",
+  )(function* (project: Effect.Success<ReturnType<typeof requireProject>>) {
+    const settings = yield* serverSettings.getSettings.pipe(
+      Effect.mapError((error) =>
+        failure("orchestration_error", `Unable to read server settings: ${error.message}`),
+      ),
+    );
+    const modelSelection = resolveProjectSettings(settings, project.id, project).settings
+      .defaultModelSelection;
+    if (modelSelection === null) {
+      return yield* failure(
+        "invalid_request",
+        `Project ${project.id} has no default model, so this caller cannot pick one for it.`,
+      );
+    }
+    return modelSelection;
+  });
   const secretRequests = yield* SecretRequests.SecretRequests;
 
   const requireCapability = (scope: McpInvocationScope) =>
 
@@ -596,3 +596,40 @@ it.effect.each([
     expect(dispatched).toEqual(settles ? ["thread.settle"] : []);
   }),
 );
+
+it.effect("listProjectThreads returns archived threads for the archive location", () =>
+  Effect.gen(function* () {
+    const threadId = ThreadId.make("thread:thread-management:archived");
+    const archived = {
+      id: threadId,
+      updatedAt: DateTime.makeUnsafe(0),
+      lineage: { relationshipToParent: null },
+    };
+    const layerTest = ThreadManagementService.layer.pipe(
+      Layer.provide(Layer.mock(ProviderSessionManager.ProviderSessionManagerV2)({})),
+      Layer.provide(
+        Layer.mock(Orchestrator.OrchestratorV2)({
+          // Mirrors ProjectionStore: an archive snapshot fills only `archivedThreads`.
+          getShellSnapshot: (input) =>
+            Effect.succeed(
+              (input?.location === "archive"
+                ? { threads: [], archivedThreads: [archived] }
+                : { threads: [], archivedThreads: [] }) as never,
+            ),
+        }),
+      ),
+      Layer.provide(ServerSettings.layerTest()),
+      Layer.provide(layerReceiptsTest),
+    );
+    const service = yield* ThreadManagementService.ThreadManagementService.pipe(
+      Effect.provide(layerTest),
+    );
+
+    const threads = yield* service.listProjectThreads({
+      location: "archive",
+      includeSubagents: false,
+    });
+
+    expect(threads.map((thread) => thread.id)).toEqual([threadId]);
+  }),
+);
@@ -767,8 +767,9 @@ const make = Effect.gen(function* () {
               cause,
             }),
         ),
+        // The snapshot keeps archived rows apart; `location` already picked which side is filled.
         Effect.map((snapshot) =>
-          snapshot.threads
+          [...snapshot.threads, ...snapshot.archivedThreads]
             .filter(
               (thread) =>
                 input.includeSubagents || thread.lineage.relationshipToParent !== "subagent",