@nowcrew/daemon 0.6.16 → 0.6.18

package/dist/runtimes/codex-app-server-runner.js

@@ -1,10 +1,12 @@
 import { once } from "node:events";
+import { realpathSync } from "node:fs";
 import { createInterface } from "node:readline";
 import { parseArgs } from "node:util";
 import { pathToFileURL } from "node:url";
 import spawn from "cross-spawn";
 import { z } from "zod";
 import { signalSupervisorTree } from "../execution-supervisor.js";
+import { assertCodexNativeWorkspaceVersion, assertCodexProjectWorkspaceResponse, assertCodexSkillsListResponse, boundedCodexPlan, codexProjectWorkspaceUnsupported, } from "./codex-contract.js";
 import { startFirstProgressWatchdog } from "./progress-watchdog.js";
 const RunnerInputSchema = z.object({
     systemPrompt: z.string().min(1),
@@ -15,6 +17,9 @@ const RunnerInputSchema = z.object({
     sessionId: z.string().min(1).optional(),
     imagePaths: z.array(z.string().min(1)).optional(),
     projectRootMarkers: z.array(z.string().min(1).max(64).regex(/^[A-Za-z0-9._-]+$/u)).max(16).optional(),
+    cwd: z.string().min(1).optional(),
+    workspaceRoots: z.array(z.string().min(1)).optional(),
+    skillRoots: z.array(z.string().min(1)).optional(),
     resume: z.boolean(),
 }).strict();
 const RPC_TIMEOUT_MS = 30_000;
@@ -32,6 +37,7 @@ const MAX_TRANSIENT_TURN_RETRIES = 2;
 const TRANSIENT_TURN_RETRY_DELAY_MS = 15_000;
 const TRANSIENT_TURN_RETRY_BACKOFF_FACTOR = 3;
 const PROCESS_TREE_STOP_TIMEOUT_MS = 1_000;
+const USER_INPUT_UNAVAILABLE_MESSAGE = "NowWork cannot collect interactive user input in this headless run; ask the user in the final response instead of assuming an answer.";
 export function codexAppServerArgs(projectRootMarkers) {
     return [
         ...(projectRootMarkers === undefined
@@ -65,12 +71,8 @@ export function codexRpcTimeoutMs(method) {
     return method === "initialize" ? INITIALIZE_RPC_TIMEOUT_MS : RPC_TIMEOUT_MS;
 }
 function safeErrorMessage(error, secrets) {
-    let message = error instanceof Error ? error.message : String(error);
-    for (const secret of secrets) {
-        if (secret)
-            message = message.replaceAll(secret, "[prompt redacted]");
-    }
-    return message.slice(0, ERROR_MESSAGE_CAP);
+    const message = error instanceof Error ? error.message : String(error);
+    return sanitizeCodexDiagnostic(message, secrets).slice(0, ERROR_MESSAGE_CAP);
 }
 function sensitiveEnvironmentValues(env) {
     return Object.entries(env)
@@ -79,13 +81,34 @@ function sensitiveEnvironmentValues(env) {
         .map(([, value]) => value);
 }
 function redactionSecrets(input, env) {
-    const values = [input.systemPrompt, input.wakePrompt, ...sensitiveEnvironmentValues(env)];
+    const pathValues = [
+        process.cwd(),
+        ...(input.imagePaths ?? []),
+        ...(input.cwd === undefined ? [] : [input.cwd]),
+        ...(input.workspaceRoots ?? []),
+        ...(input.skillRoots ?? []),
+    ];
+    const realpathAliases = pathValues.flatMap((value) => {
+        try {
+            return [realpathSync.native(value)];
+        }
+        catch {
+            return [];
+        }
+    });
+    const values = [
+        input.systemPrompt,
+        input.wakePrompt,
+        ...pathValues,
+        ...realpathAliases,
+        ...sensitiveEnvironmentValues(env),
+    ];
     return [...new Set(values.flatMap((value) => [
             value,
             ...value.split(/\r?\n/).map((line) => line.trim()),
         ]).filter(Boolean))];
 }
-export function redactCodexStderr(text, secrets) {
+export function sanitizeCodexDiagnostic(text, secrets) {
     let redacted = text;
     for (const secret of [...secrets].sort((left, right) => right.length - left.length)) {
         if (secret)
@@ -93,9 +116,13 @@ export function redactCodexStderr(text, secrets) {
     }
     return redacted
         .replace(/(Bearer\s+)[^\s"']+/gi, "$1[redacted]")
-        .replace(/\bsk-[A-Za-z0-9_-]{6,}\b/g, "[redacted]")
-        .replace(/((?:api[_-]?key|access[_-]?token|auth(?:orization)?|password|secret)\s*[=:]\s*)[^\s"']+/gi, "$1[redacted]");
+        .replace(/\bsk[-_][A-Za-z0-9_-]{6,}\b/gi, "[redacted]")
+        .replace(/((?:api[_-]?key|access[_-]?token|auth[_-]?token|token|auth(?:orization)?|password|secret)\s*[=:]\s*)[^\s"']+/gi, "$1[redacted]")
+        .replace(/(^|[\s"'(=:[{])(?:[A-Za-z]:[\\/]|\\\\)[^\s"'`<>|]+/g, "$1[redacted-path]")
+        .replace(/(^|[\s"'(=:[{])\/[^\s"'`<>|]+/g, "$1[redacted-path]");
 }
+/** @deprecated Use the shared diagnostic sanitizer for every runner-owned error surface. */
+export const redactCodexStderr = sanitizeCodexDiagnostic;
 class StderrCapture {
     secrets;
     tail = "";
@@ -110,7 +137,7 @@ class StderrCapture {
     redactedTail() {
         const pending = this.omittingLine
             ? STDERR_LINE_OMITTED
-            : redactCodexStderr(this.pendingLine, this.secrets);
+            : sanitizeCodexDiagnostic(this.pendingLine, this.secrets);
         return `${this.tail}${pending}`.slice(-STDERR_TAIL_CAP).trim();
     }
     append(chunk) {
@@ -143,7 +170,7 @@ class StderrCapture {
         this.omittingLine = false;
     }
     emit(text) {
-        const redacted = redactCodexStderr(text, this.secrets);
+        const redacted = sanitizeCodexDiagnostic(text, this.secrets);
         process.stderr.write(redacted);
         this.tail = `${this.tail}${redacted}`.slice(-STDERR_TAIL_CAP);
     }
@@ -171,16 +198,26 @@ export function codexApprovalResponse(method, permission) {
         || method === "item/fileChange/requestApproval") {
         return { decision: permission === "full_access" ? "accept" : "decline" };
     }
-    if (method === "item/tool/requestUserInput")
-        return { answers: {} };
+    if (method === "item/tool/requestUserInput") {
+        return { error: { code: -32002, message: USER_INPUT_UNAVAILABLE_MESSAGE } };
+    }
     return null;
 }
 /** Translate app-server v2 notifications into the daemon's existing runtime event contract. */
 export function mapCodexNotification(method, params) {
-    const value = params;
+    const value = (params !== null && typeof params === "object" ? params : {});
     if (method === "thread/started" && value.thread?.id) {
         return [{ type: "thread.started", thread_id: value.thread.id }];
     }
+    const plan = method === "turn/plan/updated" ? boundedCodexPlan(value.plan) : null;
+    if (plan !== null && typeof value.threadId === "string" && typeof value.turnId === "string") {
+        return [{
+                type: "turn.plan.updated",
+                thread_id: value.threadId,
+                turn_id: value.turnId,
+                plan,
+            }];
+    }
     if (method !== "item/completed" || value.item === undefined)
         return [];
     if (value.item.type === "agentMessage" && value.item.text) {
@@ -221,14 +258,16 @@ class CodexRpcClient {
     permission;
     onNotification;
     onFatal;
+    diagnosticSecrets;
     nextId = 1;
     pending = new Map();
     closedError = null;
-    constructor(child, permission, onNotification, onFatal) {
+    constructor(child, permission, onNotification, onFatal, diagnosticSecrets) {
         this.child = child;
         this.permission = permission;
         this.onNotification = onNotification;
         this.onFatal = onFatal;
+        this.diagnosticSecrets = diagnosticSecrets;
         if (child.stdin === null || child.stdout === null) {
             throw new Error("Codex app-server did not expose stdio");
         }
@@ -272,7 +311,7 @@ class CodexRpcClient {
             message = JSON.parse(line);
         }
         catch {
-            process.stderr.write(`Codex app-server emitted invalid JSON: ${line.slice(0, 500)}\n`);
+            process.stderr.write(sanitizeCodexDiagnostic(`Codex app-server emitted invalid JSON: ${line.slice(0, 500)}\n`, this.diagnosticSecrets));
             return;
         }
         if (message.id !== undefined && message.method !== undefined) {
@@ -284,6 +323,10 @@ class CodexRpcClient {
                     error: { code: -32001, message: `NowCrew denied unsupported request ${message.method}` },
                 });
             }
+            else if (result.error !== undefined && typeof result.error === "object" && result.error !== null) {
+                process.stderr.write("[codex-app-server] interactive user input is unavailable; returned a truthful RPC error\n");
+                this.write({ jsonrpc: "2.0", id: message.id, error: result.error });
+            }
             else {
                 this.write({ jsonrpc: "2.0", id: message.id, result });
             }
@@ -416,9 +459,9 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
         if (method === "error" && params.willRetry === false) {
             const detail = params.error?.message;
             if (detail)
-                process.stderr.write(`Codex turn error: ${detail.slice(0, ERROR_MESSAGE_CAP)}\n`);
+                process.stderr.write(sanitizeCodexDiagnostic(`Codex turn error: ${detail.slice(0, ERROR_MESSAGE_CAP)}\n`, secrets));
         }
-    }, completionReject);
+    }, completionReject, secrets);
     let treeStopPromise = null;
     const ensureChildTreeStopped = () => {
         treeStopPromise ??= stopChildTree(child);
@@ -440,30 +483,62 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
     let activeStage = "initialize";
     let stageStartedAt = Date.now();
     try {
-        await rpc.request("initialize", {
+        const initialized = await rpc.request("initialize", {
             clientInfo: { name: "nowcrew-daemon", version: "1" },
             capabilities: { experimentalApi: true, requestAttestation: false },
         }, initializeTimeoutMs);
+        if (input.workspaceRoots !== undefined || input.skillRoots !== undefined) {
+            assertCodexNativeWorkspaceVersion(initialized);
+        }
         logStage(activeStage, "ok", attempt, stageStartedAt);
         rpc.notify("initialized");
         activeStage = input.resume ? "thread_resume" : "thread_start";
         stageStartedAt = Date.now();
+        const threadCwd = input.cwd ?? process.cwd();
         const threadParams = {
-            cwd: process.cwd(),
+            cwd: threadCwd,
+            ...(input.workspaceRoots === undefined
+                ? {}
+                : { runtimeWorkspaceRoots: input.workspaceRoots }),
             approvalPolicy: "never",
             sandbox: sandboxMode(input.effectivePermission),
             developerInstructions: input.systemPrompt,
             ...(input.model === undefined ? {} : { model: input.model }),
         };
-        const thread = input.resume && input.sessionId !== undefined
-            ? await rpc.request("thread/resume", { threadId: input.sessionId, ...threadParams })
-            : await rpc.request("thread/start", threadParams);
+        let thread;
+        const nativeContractRequired = input.workspaceRoots !== undefined || input.skillRoots !== undefined;
+        try {
+            thread = input.resume && input.sessionId !== undefined
+                ? await rpc.request("thread/resume", { threadId: input.sessionId, ...threadParams })
+                : await rpc.request("thread/start", threadParams);
+        }
+        catch (error) {
+            if (nativeContractRequired)
+                throw codexProjectWorkspaceUnsupported();
+            throw error;
+        }
+        if (nativeContractRequired) {
+            thread = assertCodexProjectWorkspaceResponse(thread, {
+                cwd: threadCwd,
+                workspaceRoots: input.workspaceRoots ?? [],
+            });
+        }
         logStage(activeStage, "ok", attempt, stageStartedAt);
         threadId = thread.thread.id;
         if (announcedThreadId !== threadId) {
             announcedThreadId = threadId;
             await jsonLine({ type: "thread.started", thread_id: threadId });
         }
+        if (input.skillRoots !== undefined) {
+            try {
+                await rpc.request("skills/extraRoots/set", { extraRoots: input.skillRoots });
+                const listed = await rpc.request("skills/list", { cwds: [threadCwd], forceReload: true });
+                assertCodexSkillsListResponse(listed, threadCwd);
+            }
+            catch {
+                throw codexProjectWorkspaceUnsupported();
+            }
+        }
         firstProgress = startFirstProgressWatchdog(() => {
             completionReject(new Error("Codex produced no semantic progress within the startup window"));
             void cancel();
@@ -501,7 +576,7 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
         if (completed.turn?.status === "completed")
             return { code: 0, initializeTimedOut: false };
         const detail = completed.turn?.error?.message ?? `turn status ${completed.turn?.status ?? "unknown"}`;
-        process.stderr.write(`Codex turn failed: ${detail.slice(0, ERROR_MESSAGE_CAP)}\n`);
+        process.stderr.write(sanitizeCodexDiagnostic(`Codex turn failed: ${detail.slice(0, ERROR_MESSAGE_CAP)}\n`, secrets));
         return {
             code: completed.turn?.status === "interrupted" ? 130 : 1,
             initializeTimedOut: false,

package/dist/runtimes/codex-contract.js

@@ -0,0 +1,123 @@
+import { CODEX_NATIVE_WORKSPACE_MIN_VERSION } from "./codex.js";
+import { z } from "zod";
+export const CODEX_PROJECT_WORKSPACE_UNSUPPORTED = "codex_project_workspace_unsupported";
+export const CODEX_PLAN_ENTRY_LIMIT = 16;
+// 16 steps remain inside the server's 4,000 UTF-16-unit plan payload cap even
+// when every retained code point is a surrogate pair (for example, emoji).
+export const CODEX_PLAN_STEP_TEXT_LIMIT = 120;
+const NativeInitializeResponseSchema = z.object({
+    userAgent: z.string().min(1),
+    codexHome: z.string().min(1),
+    platformFamily: z.string().min(1),
+    platformOs: z.string().min(1),
+}).passthrough();
+const NativeThreadWorkspaceSchema = z.object({
+    thread: z.object({ id: z.string().min(1) }).passthrough(),
+    cwd: z.string().min(1),
+    runtimeWorkspaceRoots: z.array(z.string().min(1)),
+    instructionSources: z.array(z.string().min(1)),
+}).strict();
+const SkillMetadataSchema = z.object({
+    name: z.string().min(1),
+    description: z.string(),
+    shortDescription: z.string().optional(),
+    interface: z.unknown().optional(),
+    dependencies: z.unknown().optional(),
+    path: z.string().min(1),
+    scope: z.string().min(1),
+    enabled: z.boolean(),
+}).passthrough();
+const SkillsListResponseSchema = z.object({
+    data: z.array(z.object({
+        cwd: z.string().min(1),
+        skills: z.array(SkillMetadataSchema),
+        errors: z.array(z.object({
+            path: z.string(),
+            message: z.string(),
+        }).passthrough()),
+    }).passthrough()),
+}).passthrough();
+const stringArrayEquals = (value, expected) => Array.isArray(value)
+    && value.length === expected.length
+    && value.every((entry, index) => typeof entry === "string" && entry === expected[index]);
+const versionTuple = (version) => {
+    const match = /^(\d+)\.(\d+)\.(\d+)$/u.exec(version);
+    if (match === null)
+        return null;
+    const [, major = "0", minor = "0", patch = "0"] = match;
+    const tuple = [Number(major), Number(minor), Number(patch)];
+    return tuple.every(Number.isSafeInteger) ? tuple : null;
+};
+const versionAtLeast = (actual, minimum) => actual[0] > minimum[0]
+    || (actual[0] === minimum[0] && (actual[1] > minimum[1]
+        || (actual[1] === minimum[1] && actual[2] >= minimum[2])));
+/** Native roots require the app-server version returned by initialize, not a separate shell probe. */
+export function assertCodexNativeWorkspaceVersion(response) {
+    const parsed = NativeInitializeResponseSchema.safeParse(response);
+    if (!parsed.success)
+        throw codexProjectWorkspaceUnsupported();
+    const match = /(?:^|[/\s])(\d+\.\d+\.\d+)(?=$|[\s(])/u.exec(parsed.data.userAgent);
+    const actual = match === null ? null : versionTuple(match[1] ?? "");
+    const minimum = versionTuple(CODEX_NATIVE_WORKSPACE_MIN_VERSION);
+    if (actual === null || minimum === null || !versionAtLeast(actual, minimum)) {
+        throw codexProjectWorkspaceUnsupported();
+    }
+}
+const PLAN_STATUSES = new Set(["pending", "inProgress", "completed"]);
+const clipCharacters = (value, limit) => [...value.trim().replace(/\s+/gu, " ")].slice(0, limit).join("");
+/** Treat plan updates as bounded user-visible data; any malformed retained step rejects the event. */
+export function boundedCodexPlan(raw) {
+    if (!Array.isArray(raw) || raw.length === 0)
+        return null;
+    const plan = [];
+    for (const entry of raw.slice(0, CODEX_PLAN_ENTRY_LIMIT)) {
+        if (entry === null || typeof entry !== "object")
+            return null;
+        const value = entry;
+        if (typeof value.step !== "string"
+            || typeof value.status !== "string"
+            || !PLAN_STATUSES.has(value.status))
+            return null;
+        const step = clipCharacters(value.step, CODEX_PLAN_STEP_TEXT_LIMIT);
+        if (step === "")
+            return null;
+        plan.push(Object.freeze({ step, status: value.status }));
+    }
+    return Object.freeze(plan);
+}
+export function codexPlanText(plan) {
+    const marker = {
+        pending: " ", inProgress: "~", completed: "x",
+    };
+    return plan.map(({ step, status }) => `- [${marker[status]}] ${step}`).join("\n");
+}
+/** Bound launches require the experimental workspace fields to round-trip before any model turn. */
+export function assertCodexProjectWorkspaceResponse(response, expected) {
+    const raw = response !== null && typeof response === "object"
+        ? response
+        : {};
+    // Validate a strict projection so additions to the upstream response remain forward-compatible.
+    const parsed = NativeThreadWorkspaceSchema.safeParse({
+        thread: raw.thread,
+        cwd: raw.cwd,
+        runtimeWorkspaceRoots: raw.runtimeWorkspaceRoots,
+        instructionSources: raw.instructionSources,
+    });
+    if (!parsed.success
+        || parsed.data.cwd !== expected.cwd
+        || !stringArrayEquals(parsed.data.runtimeWorkspaceRoots, expected.workspaceRoots)) {
+        throw codexProjectWorkspaceUnsupported();
+    }
+    return parsed.data;
+}
+export function assertCodexSkillsListResponse(response, requestedCwd) {
+    const parsed = SkillsListResponseSchema.safeParse(response);
+    if (!parsed.success
+        || !parsed.data.data.some((entry) => entry.cwd === requestedCwd)
+        || parsed.data.data.some((entry) => entry.errors.length > 0)) {
+        throw codexProjectWorkspaceUnsupported();
+    }
+}
+export function codexProjectWorkspaceUnsupported() {
+    return new Error(CODEX_PROJECT_WORKSPACE_UNSUPPORTED);
+}

package/dist/runtimes/codex.js

@@ -3,6 +3,8 @@
  */
 // cross-spawn:win32 上 npm CLI 是 .cmd shim,node 原生 spawn 不带 shell 无法执行(ENOENT/EINVAL)
 import spawn from "cross-spawn";
+/** Minimum CLI whose real app-server contract supports NowCrew native project workspaces. */
+export const CODEX_NATIVE_WORKSPACE_MIN_VERSION = "0.148.0";
 // Codex CLI 原生 model_reasoning_effort 档位(codex 0.135.0 实测:非法值时 config 解析报错枚举这六档)。
 // 注意:codex 对非法值是硬失败(进程直接退出),所以必须白名单过滤;白名单外(含 "default"、
 // claude 专属的 "max")回落 CODEX_DEFAULT_EFFORT。

package/dist/serve.js

@@ -8,7 +8,7 @@ import { randomUUID } from "node:crypto";
 import { initSlog, dslog, setSlogDefaults, drainSpool, flushSlog } from "./slog.js";
 import { mergeRunAgentResults, reportScheduledStartFailure, runAgent } from "./runner.js";
 import { buildOriginDecisionRetryPrompt, buildScheduledPrompt } from "./prompt.js";
-import { collectMachineHello, cliVersion, daemonVersion, detectExecutionRuntimesWithSignal, } from "./machine-info.js";
+import { collectMachineHello, cliVersion, daemonCapabilityBindings, daemonVersion, detectExecutionRuntimesWithSignal, } from "./machine-info.js";
 import { conservativeExecutionRuntimes, createRuntimeProbeCoordinator, } from "./runtime-probe.js";
 import { listWorkspace, readWorkspaceFile } from "./workspace-fs.js";
 import { listSkills } from "./skills.js";
@@ -21,7 +21,7 @@ import { runWithOriginDecisionGuard } from "./origin-decision.js";
 import { createExecutionJournal } from "./execution-journal.js";
 import { createExecutionTelemetryJournal } from "./execution-telemetry-journal.js";
 import { ExecutionRejectedSchema, ExecutionSnapshotSchema, LegacyAgentStartSchema, ServerToDaemonExecutionFrameSchema, } from "./execution-protocol.js";
-import { hashExecutionSpec, runExecution, } from "./execution-runner.js";
+import { hashExecutionSpec, projectWorkspaceCapabilityRejection, runExecution, } from "./execution-runner.js";
 import { awaitWithCancellation, createRuntimeCancellation, RuntimeCancelledError, } from "./runtime-cancellation.js";
 import { createShutdownDeadline, readTestShutdownConfiguration } from "./shutdown-deadline.js";
 import { closeWebSocketWithinDeadline } from "./websocket-shutdown.js";
@@ -40,10 +40,12 @@ import { createProjectSkillsController, } from "./project-skills/controller.js";
 import { PROJECT_SKILLS_CAPABILITY } from "./project-skills/types.js";
 import { createAgentProjectionCoordinator } from "./project-skills/agent-projection-coordinator.js";
 import { createAgentAbilityRuntime } from "./agent-ability/runtime.js";
-import { createProjectSkillsReconciler, ProjectProjectionError, } from "./project-skills/reconciler.js";
+import { createProjectSkillsReconciler, } from "./project-skills/reconciler.js";
+import { initializedProjectSkillsReconciler } from "./project-skills/initialized-reconciler.js";
 import { parseMemoryPruneTraceId } from "./memory-prune-diagnostics.js";
 import { handleRuntimeProbeFrame, probeRuntimeHealth } from "./runtime-health.js";
 import { buildControlPlaneUrl } from "./control-plane-url.js";
+import { createServeMigrationController, handleMigrationControlMessage } from "./daemon-migration-wiring.js";
 export { buildControlPlaneUrl } from "./control-plane-url.js";
 // normalize.ts 的活动种类 → activity 枚举
 const ACTIVITY_MAP = {
@@ -104,6 +106,16 @@ export function serve(config, opts = {}) {
             catch { /* reconnect/timeout reconciliation handles a lost status frame */ }
         },
     });
+    const migrationController = createServeMigrationController({
+        config,
+        ...(opts.profileName === undefined ? {} : { profileName: opts.profileName }),
+        isBusy: () => executionRuns.size > 0 || legacyRuns.size > 0,
+        sendStatus: (frame) => { try {
+            if (ws?.readyState === WebSocket.OPEN)
+                ws.send(JSON.stringify(frame));
+        }
+        catch { /* reconnect */ } },
+    });
     const projectionCoordinator = createAgentProjectionCoordinator();
     const agentAbilityRuntime = createAgentAbilityRuntime(config.agentsRoot, {
         ...opts.agentAbility,
@@ -127,6 +139,7 @@ export function serve(config, opts = {}) {
             catch { /* 下一次 ready 或项目操作会重新发送完整快照 */ }
         },
         reconcile: (handle, bindings) => projectSkillsReconciler.reconcile(handle, bindings),
+        ensureSnapshot: (handle, snapshot) => projectSkillsReconciler.ensureSnapshot(handle, snapshot),
     });
     let projectSkillsStatus = "initializing";
     let projectSkillsInitialization = null;
@@ -172,18 +185,7 @@ export function serve(config, opts = {}) {
         projectSkillsInitialization = attempt;
         return attempt;
     };
-    const initializedProjectSkillsReconciler = {
-        async reconcile(handle, bindings) {
-            return await ensureProjectSkillsInitialized()
-                ? projectSkillsReconciler.reconcile(handle, bindings)
-                : Promise.reject(new ProjectProjectionError("skill_projection_failed"));
-        },
-        async prepareAndLaunch(agentsRoot, handle, bindings, launch) {
-            return await ensureProjectSkillsInitialized()
-                ? projectSkillsReconciler.prepareAndLaunch(agentsRoot, handle, bindings, launch)
-                : Promise.reject(new ProjectProjectionError("skill_projection_failed"));
-        },
-    };
+    const initializedProjectSkills = initializedProjectSkillsReconciler(ensureProjectSkillsInitialized, projectSkillsReconciler);
     const safeExecutionSend = (frame) => {
         try {
             if (ws?.readyState !== WebSocket.OPEN)
@@ -281,6 +283,7 @@ export function serve(config, opts = {}) {
             reservation.release();
     };
     let connectedAt = 0; // 本次 WS 连接建立时刻(断开日志算在线时长用)
+    const capabilities = daemonCapabilityBindings(process.platform, opts.machineInfo?.capabilities);
     initSlog(config.serverUrl, config.machineToken, { daemonVersion: daemonVersion(), cliVersion: cliVersion(), ...(opts.profileName === undefined ? {} : { profileName: opts.profileName }), agentsRoot: config.agentsRoot });
     dslog("daemon.start", "daemon 常驻模式启动", { server_url: config.serverUrl, runtime: config.runtimeBin });
     // 并行调度:同一 agent 可并行处理多个【不同任务】(线程/频道),每任务隔离 cwd+work-log。
@@ -293,7 +296,7 @@ export function serve(config, opts = {}) {
     function connect() {
         if (stopped)
             return;
-        const wsUrl = buildControlPlaneUrl(config.serverUrl, config.machineToken, process.platform, undefined, projectSkillsStatus === "ready");
+        const wsUrl = buildControlPlaneUrl(config.serverUrl, config.machineToken, process.platform, undefined, projectSkillsStatus === "ready", capabilities.controlPlaneUrl);
         ws = createWebSocket(wsUrl);
         ws.on("open", () => {
             const openedSocket = ws;
@@ -307,9 +310,11 @@ export function serve(config, opts = {}) {
             const { detectInstalled, detectExecutable = detectExecutionRuntimesWithSignal } = opts.machineInfo ?? {};
             const helloPromise = collectMachineHello(config.agentsRoot, config.executionLimits, process.platform, {
                 ...(detectInstalled ? { detectInstalled } : {}),
+                ...(opts.profileName === undefined ? {} : { profileName: opts.profileName }),
                 // First hello must not wait for third-party handshakes; optional transports arrive in the refresh.
                 detectExecutable: async (installed) => conservativeExecutionRuntimes(installed),
                 additionalCapabilities: () => managedDaemonCapabilities(updateEligibility),
+                capabilities: capabilities.machineHello,
             });
             runtimeFacts = helloPromise
                 .then(async (hello) => {
@@ -390,6 +395,10 @@ export function serve(config, opts = {}) {
                 });
                 return;
             }
+            if (rawType === "daemon:migrate") {
+                void handleMigrationControlMessage(migrationController, decoded).catch((error) => dslog("daemon.migration_failed", "daemon 布局迁移失败", { level: "ERROR", error_message: error.message }));
+                return;
+            }
             if (rawType.startsWith("execution:")) {
                 const parsedExecution = ServerToDaemonExecutionFrameSchema.safeParse(decoded);
                 if (!parsedExecution.success) {
@@ -451,6 +460,9 @@ export function serve(config, opts = {}) {
                         return;
                     }
                     const spec = frame;
+                    const workspaceRejection = projectWorkspaceCapabilityRejection(spec, capabilities.executionRunner, new Date().toISOString());
+                    if (workspaceRejection !== null)
+                        return void safeExecutionSend(workspaceRejection);
                     const hash = hashExecutionSpec(spec);
                     const knownHash = knownExecutionHashes.get(spec.executionId);
                     if (knownHash !== undefined) {
@@ -587,7 +599,8 @@ export function serve(config, opts = {}) {
                     }
                     const execution = executeProtocol(config, spec, {
                         ...opts.execution?.dependencies,
-                        projectSkills: opts.execution?.dependencies?.projectSkills ?? initializedProjectSkillsReconciler,
+                        capabilities: capabilities.executionRunner,
+                        projectSkills: opts.execution?.dependencies?.projectSkills ?? initializedProjectSkills,
                         abilityRelease: opts.execution?.dependencies?.abilityRelease ?? agentAbilityRuntime.materializer,
                         ...(agentMemory === undefined ? {} : { agentMemory }),
                         journal: executionJournal,
@@ -1154,6 +1167,7 @@ export function serve(config, opts = {}) {
             const pending = [
                 webSocketClosed,
                 updateController.drain(),
+                ...(migrationController === null ? [] : [migrationController.drain()]),
                 executionFrameQueue,
                 ...executionRuns.values(),
                 ...[...legacyRuns.values()].map((run) => run.done),

package/dist/session.js

@@ -29,6 +29,9 @@ export async function readSession(runDir) {
             turns: typeof o.turns === "number" ? o.turns : 0,
             model: typeof o.model === "string" ? o.model : null,
             providerFingerprint: typeof o.providerFingerprint === "string" ? o.providerFingerprint : null,
+            ...(typeof o.sessionContextFingerprint === "string"
+                ? { sessionContextFingerprint: o.sessionContextFingerprint }
+                : {}),
             ...(typeof o.contextTokens === "number" && o.contextTokens >= 0 ? { contextTokens: o.contextTokens } : {}),
             ...(typeof o.lastExitOk === "boolean" ? { lastExitOk: o.lastExitOk } : {}),
         };

package/dist/supervised-runtime.js

@@ -13,6 +13,10 @@ export function supervisorLaunch(request) {
         ...(request.reasoning === undefined ? {} : { reasoning: request.reasoning }),
     };
     if (request.runtime === "claude") {
+        const additionalDirectories = request.claudeAdditionalDirectories
+            ?? (request.agentRoot === undefined
+                ? undefined
+                : [join(request.agentRoot, ".crew", "claude-skills"), request.agentRoot]);
         return {
             command: request.bin,
             args: buildClaudeArgs({
@@ -21,10 +25,7 @@ export function supervisorLaunch(request) {
                 cwd: request.cwd,
                 env: request.env,
                 systemPromptPath: request.systemPromptPath,
-                ...(request.agentRoot === undefined ? {} : {
-                    projectSkillsDirectory: join(request.agentRoot, ".crew", "claude-skills"),
-                    agentRootDirectory: request.agentRoot,
-                }),
+                ...(additionalDirectories === undefined ? {} : { additionalDirectories }),
                 ...(request.sessionId === undefined ? {} : {
                     sessionId: request.sessionId,
                     resume: request.resume,
@@ -54,6 +55,13 @@ export function supervisorLaunch(request) {
                 ...(request.agentRoot === undefined ? {} : {
                     projectRootMarkers: [".git", ".nowwork-root"],
                 }),
+                ...(request.workspaceRoots === undefined ? {} : {
+                    cwd: request.cwd,
+                    workspaceRoots: request.workspaceRoots,
+                }),
+                ...(request.codexSkillRoots === undefined ? {} : {
+                    skillRoots: request.codexSkillRoots,
+                }),
                 resume: request.resume,
             }),
         };

package/dist/workspace.js

@@ -88,14 +88,23 @@ export async function prepareWorkspace(input) {
     }
     const workLog = (await exists(workLogPath)) ? await readFile(workLogPath, "utf8") : "";
     // resumeKey 可跨不同 task cwd 维持同一底层会话；协议键用 opaque 映射,legacy 保持 safeKey。
-    const sessionDir = input.resumeKey
-        ? join(crewDir, "sessions", workspaceKey(input.resumeKey, input.keyMode))
-        : runDir;
-    if (input.resumeKey)
+    // 未绑定项目时保留原有分支，避免改变旧 sessionDir 与 import 语义。
+    let sessionDir;
+    if (input.sessionContextFingerprint === undefined) {
+        sessionDir = input.resumeKey
+            ? join(crewDir, "sessions", workspaceKey(input.resumeKey, input.keyMode))
+            : runDir;
+        if (input.resumeKey)
+            await mkdir(sessionDir, { recursive: true });
+    }
+    else {
+        const effectiveSessionKey = `${input.resumeKey ?? input.taskKey}\0${input.sessionContextFingerprint}`;
+        sessionDir = join(crewDir, "sessions", workspaceKey(effectiveSessionKey, input.keyMode));
         await mkdir(sessionDir, { recursive: true });
+    }
     let agentSessionId = null;
     let sessionResume = false;
-    if (input.taskKey || input.resumeKey) {
+    if (input.taskKey || input.resumeKey || input.sessionContextFingerprint !== undefined) {
         const sessionPath = join(sessionDir, ".session");
         if (await exists(sessionPath)) {
             agentSessionId = (await readFile(sessionPath, "utf8")).trim() || null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.16",
+  "version": "0.6.18",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -16,9 +16,16 @@
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "daemon": "pnpm --filter @nowcrew/cli build && tsx src/main.ts",
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "pnpm build && node ../scripts/daemon-release-artifact.mjs --strict-registry",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.2.1",
-    "@nowcrew/cli": "^0.4.13",
+    "@nowcrew/cli": "^0.4.14",
     "cross-spawn": "^7.0.6",
     "ws": "^8",
     "yaml": "^2.8.1",
@@ -34,11 +41,5 @@
     "tsx": "^4.19.0",
     "typescript": "^5.6.0",
     "vitest": "^2.1.0"
-  },
-  "scripts": {
-    "daemon": "pnpm --filter @nowcrew/cli build && tsx src/main.ts",
-    "build": "tsc -p tsconfig.json",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
   }
-}
+}