@nowcrew/daemon 0.6.16 → 0.6.18

package/dist/execution-protocol.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { AbilityRepositoryUrlSchema, SafeAbilityPathSchema, WorkspaceAbilityTargetSchema, } from "./agent-ability/types.js";
-import { MAX_AGENT_PROJECT_SKILL_BINDINGS } from "./project-skills/types.js";
+import { compareProjectSkillRefs, MAX_AGENT_PROJECT_SKILL_BINDINGS, MAX_PROJECT_ID_LENGTH, MAX_PROJECT_SKILL_NAME_LENGTH, } from "./project-skills/types.js";
 const ExecutionIdSchema = z.string().uuid();
 const ProtocolVersionSchema = z.literal(1);
 const TimestampSchema = z.string().datetime({ offset: true });
@@ -20,9 +20,61 @@ export const AgentHandleSchema = z.string().min(1).max(64).refine((handle) => ha
     && !handle.endsWith(" ")
     && Buffer.byteLength(handle, "utf8") <= 255, "agent handle must be a cross-platform safe filesystem component");
 const ProjectSkillRefSchema = z.object({
-    projectId: z.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9._-]*$/u),
-    skillName: z.string().min(1).max(128).regex(/^[a-z0-9][a-z0-9._:-]*$/u),
+    projectId: z.string().min(1).max(MAX_PROJECT_ID_LENGTH).regex(/^[a-z0-9][a-z0-9._-]*$/u),
+    skillName: z.string().min(1).max(MAX_PROJECT_SKILL_NAME_LENGTH).regex(/^[a-z0-9][a-z0-9._:-]*$/u),
 }).strict();
+const ProjectSkillBindingsSchema = z.array(ProjectSkillRefSchema).max(MAX_AGENT_PROJECT_SKILL_BINDINGS);
+const ProjectSkillProjectionBindingsSchema = ProjectSkillBindingsSchema;
+const ProjectSkillBindingGenerationSchema = z.number().int().min(0).max(MAX_PG_INTEGER);
+function validateCanonicalProjectSkillBindings(bindings, ctx) {
+    const seen = new Set();
+    for (let index = 0; index < bindings.length; index += 1) {
+        const binding = bindings[index];
+        const key = `${binding.projectId}\0${binding.skillName}`;
+        if (seen.has(key)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "duplicate_project_skill_binding",
+                path: ["projectSkills", index],
+            });
+            return;
+        }
+        seen.add(key);
+        if (index > 0 && compareProjectSkillRefs(bindings[index - 1], binding) > 0) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "project_skill_bindings_not_sorted",
+                path: ["projectSkills", index],
+            });
+            return;
+        }
+    }
+}
+export const ProjectSkillProjectionV2FieldsSchema = z.object({
+    projectSkills: ProjectSkillProjectionBindingsSchema,
+    projectSkillBindingGeneration: ProjectSkillBindingGenerationSchema,
+}).strict().superRefine((snapshot, ctx) => {
+    validateCanonicalProjectSkillBindings(snapshot.projectSkills, ctx);
+});
+const ProjectIdSchema = z.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9._-]*$/u);
+export const ProjectContextSchema = z.object({
+    projectIds: z.array(ProjectIdSchema).max(32),
+    primaryProjectId: ProjectIdSchema.optional(),
+}).strict().superRefine((value, ctx) => {
+    for (let index = 1; index < value.projectIds.length; index += 1) {
+        if (value.projectIds[index] === value.projectIds[index - 1]) {
+            ctx.addIssue({ code: "custom", message: "duplicate_project_id" });
+            break;
+        }
+        if (value.projectIds[index] < value.projectIds[index - 1]) {
+            ctx.addIssue({ code: "custom", message: "project_ids_not_sorted" });
+            break;
+        }
+    }
+    if (value.primaryProjectId && !value.projectIds.includes(value.primaryProjectId)) {
+        ctx.addIssue({ code: "custom", message: "primary_project_not_bound" });
+    }
+});
 export const AbilityReleaseSnapshotSchema = z.object({
     bindingId: z.string().uuid(),
     releaseId: z.string().uuid(),
@@ -107,21 +159,36 @@ export const ExecutionAttachmentSchema = z.object({
     mime: z.string().min(1).max(200),
     sizeBytes: z.number().int().nonnegative().max(25 * 1024 * 1024),
 }).strict();
+const ExecutionAgentSchema = z.object({
+    id: z.string().min(1),
+    handle: AgentHandleSchema,
+    memoryEnabled: z.boolean().optional(),
+    memoryAgentId: z.string().regex(/^agt-[A-Za-z0-9_-]+$/).max(100).optional(),
+    projectSkills: ProjectSkillBindingsSchema.optional(),
+    projectSkillBindingGeneration: ProjectSkillBindingGenerationSchema.optional(),
+    abilityRelease: AbilityReleaseSnapshotSchema.optional(),
+}).strict().superRefine((agent, ctx) => {
+    if (agent.projectSkillBindingGeneration === undefined)
+        return;
+    if (agent.projectSkills === undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "project_skill_generation_requires_bindings",
+            path: ["projectSkillBindingGeneration"],
+        });
+        return;
+    }
+    validateCanonicalProjectSkillBindings(agent.projectSkills, ctx);
+});
 export const ExecutionStartSchema = z.object({
     type: z.literal("execution:start"),
     protocolVersion: ProtocolVersionSchema,
     executionId: ExecutionIdSchema,
-    agent: z.object({
-        id: z.string().min(1),
-        handle: AgentHandleSchema,
-        memoryEnabled: z.boolean().optional(),
-        memoryAgentId: z.string().regex(/^agt-[A-Za-z0-9_-]+$/).max(100).optional(),
-        projectSkills: z.array(ProjectSkillRefSchema).max(MAX_AGENT_PROJECT_SKILL_BINDINGS).optional(),
-        abilityRelease: AbilityReleaseSnapshotSchema.optional(),
-    }).strict(),
+    agent: ExecutionAgentSchema,
     workspace: z.object({
         taskKey: z.string().min(1).max(200),
         resumeKey: z.string().min(1).max(200).optional(),
+        projectContext: ProjectContextSchema.optional(),
     }).strict(),
     instructions: z.object({
         language: z.enum(["zh", "en"]),

package/dist/execution-runner.js

@@ -14,6 +14,10 @@ import { readBoundImDecisionFile, resetBoundImDecisionFile } from "./bound-im-de
 import { RuntimeCancelledError } from "./runtime-cancellation.js";
 import { supervisorLaunch } from "./supervised-runtime.js";
 import { appendAgentMemoryContext } from "./agent-memory/policy.js";
+import { projectSkillExecutionProjection, projectSkillProjectionErrorCode } from "./project-skills/execution-adapter.js";
+import { createProjectRegistry } from "./project-skills/registry.js";
+import { ProjectContextUnavailableError, resolveProjectContext } from "./project-workspaces/resolver.js";
+import { PROJECT_WORKSPACES_CAPABILITY } from "./machine-info.js";
 export { supervisorLaunch } from "./supervised-runtime.js";
 const ACTIVITY_KIND = {
     init: "working",
@@ -41,6 +45,15 @@ function canonical(value) {
 export function hashExecutionSpec(spec) {
     return createHash("sha256").update(JSON.stringify(canonical(spec))).digest("hex");
 }
+/** Hashes logical identities only; local project roots are deliberately outside the encoding. */
+export function projectSessionContextFingerprint(runtime, projectContext) {
+    const encoded = JSON.stringify(canonical({
+        runtime,
+        primaryProjectId: projectContext.primaryProjectId ?? null,
+        projectIds: [...new Set(projectContext.projectIds)].sort(),
+    }));
+    return createHash("sha256").update(encoded, "utf8").digest("hex");
+}
 async function reportBestEffort(report, frame, timeoutMs) {
     let timeout;
     try {
@@ -201,6 +214,15 @@ function rejection(executionId, reason, message, at) {
         at,
     });
 }
+export function projectWorkspaceCapabilityRejection(spec, capabilities, at) {
+    const projectContext = spec.workspace.projectContext;
+    const nativeRuntime = spec.runtime.name === "codex" || spec.runtime.name === "claude";
+    return projectContext !== undefined
+        && projectContext.projectIds.length > 0
+        && (!nativeRuntime || !capabilities?.includes(PROJECT_WORKSPACES_CAPABILITY))
+        ? rejection(spec.executionId, "capability_missing", `${PROJECT_WORKSPACES_CAPABILITY} is unavailable`, at)
+        : null;
+}
 function admission(spec, config, dependencies, at) {
     const backend = executionBackendCapability(dependencies.platform ?? process.platform);
     if (!backend.supported) {
@@ -278,12 +300,15 @@ async function cancellable(promise, cancellation) {
 }
 function failedCompletion(spec, error, startedAt, finishedAt) {
     const message = error instanceof Error ? error.message : String(error);
+    const errorCode = error instanceof ProjectContextUnavailableError
+        ? error.code
+        : projectSkillProjectionErrorCode(error) ?? "local_execution_failed";
     return ExecutionCompletedSchema.parse({
         type: "execution:completed",
         protocolVersion: 1,
         executionId: spec.executionId,
         outcome: "failed",
-        errorCode: "local_execution_failed",
+        errorCode,
         errorMessage: message || "Unknown local execution failure",
         runtime: spec.runtime.name,
         ...(spec.runtime.model === undefined ? {} : { model: spec.runtime.model }),
@@ -308,6 +333,12 @@ export async function runExecution(config, input, dependencies) {
         return { kind: "rejected", frame };
     }
     const spec = parsed.data;
+    const capabilityRejection = projectWorkspaceCapabilityRejection(spec, dependencies.capabilities, initialAt);
+    if (capabilityRejection !== null) {
+        const frame = ExecutionRejectedSchema.parse(boundExecutionFrame(capabilityRejection, config.executionLimits.maxEventBytes));
+        await dependencies.report(frame);
+        return { kind: "rejected", frame };
+    }
     const bestEffortTimeoutMs = telemetryDrainTimeout(dependencies.telemetryDrainTimeoutMs);
     const specHash = hashExecutionSpec(spec);
     const replay = await dependencies.journal.get(spec.executionId);
@@ -415,6 +446,19 @@ export async function runExecution(config, input, dependencies) {
         if (dependencies.slot !== undefined) {
             await cancellable(dependencies.slot.ready, dependencies.cancellation);
         }
+        let projectContext;
+        let sessionContextFingerprint;
+        const logicalProjectContext = spec.workspace.projectContext;
+        if (logicalProjectContext !== undefined && logicalProjectContext.projectIds.length > 0) {
+            const projectSnapshot = {
+                projectIds: logicalProjectContext.projectIds,
+                ...(logicalProjectContext.primaryProjectId === undefined
+                    ? {}
+                    : { primaryProjectId: logicalProjectContext.primaryProjectId }),
+            };
+            projectContext = await cancellable(resolveProjectContext(projectSnapshot, dependencies.projectWorkspaceRegistry ?? createProjectRegistry(config.agentsRoot)), dependencies.cancellation);
+            sessionContextFingerprint = projectSessionContextFingerprint(spec.runtime.name, projectSnapshot);
+        }
         let recalledMemory = "";
         if (spec.agent.memoryEnabled === true && dependencies.agentMemory !== undefined) {
             try {
@@ -589,9 +633,13 @@ export async function runExecution(config, input, dependencies) {
             keyMode: "opaque",
             taskKey: spec.workspace.taskKey,
             ...(spec.workspace.resumeKey === undefined ? {} : { resumeKey: spec.workspace.resumeKey }),
+            ...(sessionContextFingerprint === undefined ? {} : { sessionContextFingerprint }),
+            ...(projectContext === undefined ? {} : { projectContext }),
             ...(spec.context.wakeMessageId === undefined ? {} : { wakeMessageId: spec.context.wakeMessageId }),
             ...(spec.context.attachments === undefined ? {} : { attachments: spec.context.attachments }),
-            ...(spec.agent.projectSkills === undefined ? {} : { projectSkills: spec.agent.projectSkills }),
+            ...(spec.agent.projectSkills === undefined
+                ? {}
+                : { projectSkills: projectSkillExecutionProjection(spec.agent.projectSkills, spec.agent.projectSkillBindingGeneration) }),
             ...(spec.agent.abilityRelease === undefined ? {} : { abilityRelease: spec.agent.abilityRelease }),
             maxSystemPromptBytes: systemPromptBudget,
             systemPrompt: boundedSystemPrompt,

package/dist/i18n.js

@@ -18,6 +18,7 @@ export function detectDaemonLang(env = process.env) {
 const zh = {
     "Claude session started": "Claude 会话启动",
     "Codex session started": "Codex 会话启动",
+    "Plan updated": "计划更新",
     "Files changed": "文件变更",
     "Run failed": "运行出错",
     "Run finished": "本轮结束",

package/dist/local-execution-prompt.js

@@ -0,0 +1,57 @@
+/**
+ * 本机执行提示词的合成与预算裁剪。
+ *
+ * server 提示词是权威部分,绝不裁剪;项目工作区提示词是绑定执行的强制部分,放不下就直接失败;
+ * 只有本机事实(CREW_HOME / work-log / MEMORY 注入)是可选增强,按整段丢弃或按字节截断。
+ */
+import { buildRuntimeWorkspacePrompt, capMemoryForInject, capWorkLogForInject, } from "./prompt.js";
+export function truncateUtf8(value, maxBytes) {
+    if (maxBytes <= 0)
+        return "";
+    let bytes = 0;
+    let end = 0;
+    for (const character of value) {
+        const size = Buffer.byteLength(character, "utf8");
+        if (bytes + size > maxBytes)
+            break;
+        bytes += size;
+        end += character.length;
+    }
+    return value.slice(0, end);
+}
+function takeCompletePromptSections(sections, maxBytes) {
+    return sections.reduce((state, section) => {
+        if (!state.full)
+            return state;
+        const sectionBytes = Buffer.byteLength(section, "utf8");
+        if (state.bytes + sectionBytes > maxBytes)
+            return { ...state, full: false };
+        return { value: `${state.value}${section}`, bytes: state.bytes + sectionBytes, full: true };
+    }, { value: "", bytes: 0, full: true }).value;
+}
+/** v1 server instructions opt in to daemon-owned paths and bounded local workspace context. */
+export function withLocalExecutionFacts(serverPrompt, maxBytes) {
+    return ({ workspace, resuming, projectContext }) => {
+        const memory = capMemoryForInject(workspace.memory);
+        const workLog = resuming ? "" : capWorkLogForInject(workspace.workLog);
+        const mandatoryWorkspacePrompt = buildRuntimeWorkspacePrompt(projectContext);
+        const localFactSections = [`\n\n## Local execution facts
+- $CREW_HOME: ${workspace.dir}
+- $CREW_TASK_LOG: ${workspace.workLogPath}`,
+            ...(memory ? [`\n\n## Injected MEMORY.md (bounded local context)\n${memory}`] : []),
+            ...(workLog ? [`\n\n## Injected work-log (bounded local context)\n${workLog}`] : []),
+        ];
+        const localFacts = localFactSections.join("");
+        if (mandatoryWorkspacePrompt !== "") {
+            const serverPromptBytes = Buffer.byteLength(serverPrompt, "utf8");
+            const mandatoryBytes = Buffer.byteLength(mandatoryWorkspacePrompt, "utf8");
+            const requiredBytes = serverPromptBytes + mandatoryBytes;
+            if (requiredBytes > maxBytes)
+                throw new Error("project_workspace_prompt_budget_exceeded");
+            const optionalFacts = takeCompletePromptSections(localFactSections, maxBytes - requiredBytes);
+            return `${serverPrompt}${optionalFacts}${mandatoryWorkspacePrompt}`;
+        }
+        const remaining = maxBytes - Buffer.byteLength(serverPrompt, "utf8");
+        return `${serverPrompt}${truncateUtf8(localFacts, remaining)}`;
+    };
+}

package/dist/local-executor.js

@@ -2,7 +2,7 @@ import { createInterface } from "node:readline";
 import { readFile, rm, writeFile } from "node:fs/promises";
 import { delimiter, join } from "node:path";
 import { prepareWorkspace, rotateAgentSession, safeKey, } from "./workspace.js";
-import { spawnClaude } from "./runtimes/claude.js";
+import { CLAUDE_ADDITIONAL_DIRECTORY_INSTRUCTIONS_ENV, isClaudeAdditionalDirectoryInstructionsSupported, probeClaudeVersion, resolveOrderedUniqueClaudeDirectories, spawnClaude, } from "./runtimes/claude.js";
 import { spawnCodex } from "./runtimes/codex.js";
 import { DEEPSEEK_CODEX_MODEL, DEEPSEEK_CODEX_REASONING_LEVELS, materializeDeepSeekCodexHome, } from "./runtimes/codex-deepseek-config.js";
 import { spawnKimi, KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
@@ -11,7 +11,8 @@ import { augmentedPath } from "./runtime-path.js";
 import { extractFinalText, extractRunMeta, normalizeEvent, parseLine, } from "./normalize.js";
 import { readSession, writeSession, pickResumeId, isNearBudget } from "./session.js";
 import { createConsoleFormatter } from "./console-formatter.js";
-import { capMemoryForInject, capWorkLogForInject } from "./prompt.js";
+import { withLocalExecutionFacts, } from "./local-execution-prompt.js";
+export { withLocalExecutionFacts, } from "./local-execution-prompt.js";
 import { decodeExternalOutputEvent, extractExternalAnswer, ExternalAnswerDecoder, stripExternalAnswerMarkers, } from "./external-output.js";
 import { cleanupMaterializedAttachments as cleanupAttachments, executionAttachmentDirectory, materializeAttachments, } from "./attachments.js";
 import { routeRuntimeAttachments, runtimeCapability, } from "./runtime-capabilities.js";
@@ -19,6 +20,7 @@ import { awaitWithCancellation, RuntimeCancelledError, } from "./runtime-cancell
 import { isRuntimeReadyEvent, } from "./runtime-startup-gate.js";
 import { dslog } from "./slog.js";
 import { boundedDiagnosticJsonArray } from "./diagnostic-json.js";
+import { formatProjectSkillRuntimeWarning } from "./project-skills/runtime-warning.js";
 import { diffMemoryPruneNotes, evaluateMemoryPrunePostcondition, inspectMemoryPruneFilesWithinDeadline, parseMemoryPruneTraceId, } from "./memory-prune-diagnostics.js";
 import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLocalMemoryDiagnosticsFailure, } from "./local-memory-telemetry.js";
 import { CodexStartupStageParser } from "./codex-startup-stage.js";
@@ -53,39 +55,10 @@ function logMemoryPruneDiagnosticsFailure(input, traceId, phase, error) {
         error_code: errorCode,
     });
 }
-function truncateUtf8(value, maxBytes) {
-    if (maxBytes <= 0)
-        return "";
-    let bytes = 0;
-    let end = 0;
-    for (const character of value) {
-        const size = Buffer.byteLength(character, "utf8");
-        if (bytes + size > maxBytes)
-            break;
-        bytes += size;
-        end += character.length;
-    }
-    return value.slice(0, end);
-}
-/** v1 server instructions opt in to daemon-owned paths and bounded local workspace context. */
-export function withLocalExecutionFacts(serverPrompt, maxBytes) {
-    return ({ workspace, resuming }) => {
-        const memory = capMemoryForInject(workspace.memory);
-        const workLog = resuming ? "" : capWorkLogForInject(workspace.workLog);
-        const localFacts = `\n\n## Local execution facts
-- $CREW_HOME: ${workspace.dir}
-- $CREW_TASK_LOG: ${workspace.workLogPath}${memory
-            ? `\n\n## Injected MEMORY.md (bounded local context)\n${memory}`
-            : ""}${workLog
-            ? `\n\n## Injected work-log (bounded local context)\n${workLog}`
-            : ""}`;
-        const remaining = maxBytes - Buffer.byteLength(serverPrompt, "utf8");
-        return `${serverPrompt}${truncateUtf8(localFacts, remaining)}`;
-    };
-}
 const STDERR_TAIL_CAP = 2_000;
 const MEMORY_PRUNE_DIAGNOSTICS_TIMEOUT_MS = 2_000;
 const LOCAL_MEMORY_DIAGNOSTICS_TIMEOUT_MS = 250;
+const CLAUDE_INSTRUCTION_WARNING = "claude_additional_directory_instructions_unverified";
 const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const RESERVED_ENV = new Set([
     "PATH",
@@ -95,6 +68,16 @@ const RESERVED_ENV = new Set([
     "GH_CONFIG_DIR",
     "CLOUDSDK_CONFIG",
 ]);
+function withoutClaudeInstructionFlag(env) {
+    if (!(CLAUDE_ADDITIONAL_DIRECTORY_INSTRUCTIONS_ENV in env))
+        return env;
+    const next = { ...env };
+    delete next[CLAUDE_ADDITIONAL_DIRECTORY_INSTRUCTIONS_ENV];
+    return next;
+}
+const warnRuntimeLocally = (code) => {
+    process.stderr.write(`[runtime-warning] ${code}\n`);
+};
 export function sanitizeEnvVars(raw) {
     if (!raw)
         return {};
@@ -155,14 +138,15 @@ async function launchLegacyRuntime(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 wrapChild(spawnClaude({
             ...common,
             systemPromptPath: request.systemPromptPath,
             wakePrompt: request.wakePrompt,
-            ...(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,
@@ -221,6 +205,7 @@ export async function executeLocal(input, callbacks = {}, dependencies = {}) {
         input.handle,
         input.keyMode ?? "legacy",
         input.resumeKey ?? input.taskKey ?? "",
+        ...(input.sessionContextFingerprint === undefined ? [] : [input.sessionContextFingerprint]),
     ]);
     return withKeyedLease(leaseKey, () => executeLocalUnlocked(input, callbacks, dependencies), dependencies.cancellation);
 }
@@ -247,6 +232,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             ...(input.keyMode === undefined ? {} : { keyMode: input.keyMode }),
             ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
             ...(input.resumeKey === undefined ? {} : { resumeKey: input.resumeKey }),
+            ...(input.sessionContextFingerprint === undefined
+                ? {}
+                : { sessionContextFingerprint: input.sessionContextFingerprint }),
             ...(input.launch.description ? { description: input.launch.description } : {}),
         }), dependencies.cancellation);
     }
@@ -278,9 +266,13 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         }
         const supportsNativeResume = runtime.name === "claude"
             || (dependencies.launchRuntime !== undefined && runtimeCapability(runtime.name).nativeResume);
-        const currentPrior = input.session.enabled && supportsNativeResume
+        const storedCurrentPrior = input.session.enabled && supportsNativeResume
             ? await readSession(workspace.sessionDir)
             : null;
+        const currentPrior = storedCurrentPrior !== null
+            && storedCurrentPrior.sessionContextFingerprint === input.sessionContextFingerprint
+            ? storedCurrentPrior
+            : null;
         // Interactive V1 uses collision-resistant session directories, while the
         // older legacy path stored metadata under tasks/<safe thread key>. Import
         // that metadata once so an existing thread can cross the protocol boundary
@@ -289,6 +281,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             && supportsNativeResume
             && input.keyMode === "opaque"
             && input.resumeKey !== undefined
+            && input.sessionContextFingerprint === undefined
             ? join(input.launch.agentsRoot, input.handle, "tasks", safeKey(input.resumeKey))
             : null;
         const legacyCwdMarker = legacyRunDir === null
@@ -337,6 +330,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             resuming,
             rotatedForBudget,
             nearBudget,
+            ...(input.projectContext === undefined ? {} : { projectContext: input.projectContext }),
         };
         const systemPrompt = resolvePrompt(input.systemPrompt, promptContext);
         if (input.attachments && input.attachments.length > 0) {
@@ -442,6 +436,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             CREW_TOKEN: input.launch.token,
             CREW_CHANNEL: input.channelId,
             CREW_HOME: workspace.dir,
+            CREW_TASK_DIR: executionWorkspace.runDir,
             CREW_TASK_LOG: executionWorkspace.workLogPath,
             ...(input.wakeMessageId ? { CREW_WAKE_MESSAGE_ID: input.wakeMessageId } : {}),
             XDG_CONFIG_HOME: join(workspace.homeDir, ".config"),
@@ -520,15 +515,61 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                     skill_count: abilityContext.skillCount,
                 });
             }
+            const codexSkillRoots = runtime.name === "codex" && input.projectContext !== undefined
+                ? [
+                    ...(input.projectSkills === undefined
+                        ? []
+                        : [join(workspace.dir, ".agents", "skills")]),
+                    ...(abilityContext?.skillRoot === undefined ? [] : [abilityContext.skillRoot]),
+                ]
+                : [];
+            const claudeAdditionalDirectories = runtime.name === "claude"
+                ? input.projectContext === undefined
+                    ? abilityContext?.skillRoot === undefined
+                        ? []
+                        : await resolveOrderedUniqueClaudeDirectories([
+                            join(workspace.dir, ".crew", "claude-skills"),
+                            workspace.dir,
+                            abilityContext.skillRoot,
+                        ])
+                    : await resolveOrderedUniqueClaudeDirectories([
+                        ...input.projectContext.secondary.map((project) => project.root),
+                        ...(input.projectSkills === undefined
+                            ? []
+                            : [join(workspace.dir, ".crew", "claude-skills")]),
+                        ...(abilityContext?.skillRoot === undefined ? [] : [abilityContext.skillRoot]),
+                    ], input.projectContext.primary === undefined ? [] : [input.projectContext.primary.root])
+                : [];
+            let runtimeEnv = childEnv;
+            if (runtime.name === "claude"
+                && input.projectContext !== undefined
+                && claudeAdditionalDirectories.length > 0) {
+                const version = await (dependencies.probeClaudeVersion ?? probeClaudeVersion)(runtime.name, childEnv)
+                    .catch(() => null);
+                if (isClaudeAdditionalDirectoryInstructionsSupported(version)) {
+                    runtimeEnv = {
+                        ...childEnv,
+                        [CLAUDE_ADDITIONAL_DIRECTORY_INSTRUCTIONS_ENV]: "1",
+                    };
+                }
+                else {
+                    runtimeEnv = withoutClaudeInstructionFlag(childEnv);
+                    (dependencies.warnRuntime ?? warnRuntimeLocally)(CLAUDE_INSTRUCTION_WARNING);
+                    callbacks.onConsole?.({
+                        stream: "system",
+                        text: `[runtime-warning] ${CLAUDE_INSTRUCTION_WARNING}`,
+                    });
+                }
+            }
             const launchRequest = {
                 runtime: runtime.name,
                 bin: runtime.name === "deepseek-harness" ? "dsh-acp-demo" : runtime.name,
-                cwd: executionWorkspace.runDir,
+                cwd: input.projectContext?.primary?.root ?? executionWorkspace.runDir,
                 ...(input.projectSkills === undefined && input.abilityRelease === undefined ? {} : { agentRoot: workspace.dir }),
                 systemPromptPath: workspace.systemPromptPath,
                 systemPrompt: effectiveSystemPrompt,
                 wakePrompt,
-                env: childEnv,
+                env: runtimeEnv,
                 effectivePermission: input.effectivePermission,
                 ...(launchModel === undefined ? {} : { model: launchModel }),
                 ...(launchReasoning === undefined ? {} : { reasoning: launchReasoning }),
@@ -537,6 +578,16 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 ...(attachmentPlan.nativeImagePaths.length > 0
                     ? { imagePaths: attachmentPlan.nativeImagePaths }
                     : {}),
+                ...(codexSkillRoots.length === 0
+                    ? {}
+                    : { codexSkillRoots: Object.freeze(codexSkillRoots) }),
+                ...(claudeAdditionalDirectories.length === 0
+                    ? {}
+                    : { claudeAdditionalDirectories }),
+                ...(input.projectContext === undefined ? {} : {
+                    workspaceRoots: Object.freeze(input.projectContext.secondary.map((project) => project.root)),
+                    projectContext: input.projectContext,
+                }),
             };
             memoryPruneFailurePhase = "runtime_launch";
             return launchRuntime(launchRequest);
@@ -545,7 +596,12 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             ? dependencies.abilityRelease.prepareAndLaunch(input.launch.agentsRoot, input.handle, input.abilityRelease, launchPreparedRuntime)
             : launchPreparedRuntime();
         const child = input.projectSkills !== undefined && dependencies.projectSkills !== undefined
-            ? await dependencies.projectSkills.prepareAndLaunch(input.launch.agentsRoot, input.handle, input.projectSkills, launchWithAbility)
+            ? await (Array.isArray(input.projectSkills)
+                ? dependencies.projectSkills.prepareAndLaunch(input.launch.agentsRoot, input.handle, input.projectSkills, launchWithAbility)
+                : dependencies.projectSkills.prepareAndLaunch(input.launch.agentsRoot, input.handle, input.projectSkills, launchWithAbility, (warning) => callbacks.onConsole?.({
+                    stream: "system",
+                    text: formatProjectSkillRuntimeWarning(warning),
+                })))
             : await launchWithAbility();
         localMemoryTelemetry?.markRuntimeStarted();
         memoryPruneFailurePhase = "runtime_execution";
@@ -721,6 +777,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 turns: resuming ? (prior?.turns ?? 0) + 1 : 1,
                 model: currentModel,
                 providerFingerprint: providerFp,
+                ...(input.sessionContextFingerprint === undefined
+                    ? {}
+                    : { sessionContextFingerprint: input.sessionContextFingerprint }),
                 lastExitOk: exitCode === 0,
                 ...(contextTokens === undefined ? {} : { contextTokens }),
             });

package/dist/machine-info.js

@@ -19,9 +19,15 @@ import { probeHermesAcp } from "./runtimes/hermes.js";
 import { probeOpenCodeRun } from "./runtimes/opencode.js";
 import { RUNTIME_HEALTH_PROBE_CAPABILITY } from "./runtime-health.js";
 import { probeDeepSeekHarnessAcp } from "./runtimes/deepseek-harness.js";
+import { daemonHome } from "./computer-profile.js";
 export { executableRuntimes } from "./runtime-capabilities.js";
 const execFileP = promisify(execFile);
-export const DAEMON_CAPABILITIES = [
+export const PROJECT_WORKSPACES_CAPABILITY = "project_workspaces_v1";
+export const NATIVE_PROJECT_WORKSPACE_READINESS = Object.freeze({
+    resolverReady: true,
+    nativeRuntimeAdaptersReady: true,
+});
+export const DAEMON_CAPABILITIES = Object.freeze([
     "scheduled_job_v1",
     "reply_origin_v1",
     "origin_decision_v1",
@@ -33,17 +39,35 @@ export const DAEMON_CAPABILITIES = [
     "execution_agent_memory_policy_v1",
     "execution_agent_memory_mapping_v1",
     "project_skills_v1",
+    PROJECT_WORKSPACES_CAPABILITY,
     RUNTIME_HEALTH_PROBE_CAPABILITY,
     "agent_ability_release_v1",
     "agent_ability_workspace_v1",
     "agent_ability_runtime_assets_v1",
-];
-export const daemonCapabilities = (runtimePlatform = process.platform) => runtimePlatform === "darwin" || runtimePlatform === "linux"
-    ? DAEMON_CAPABILITIES
-    : DAEMON_CAPABILITIES.filter((capability) => capability !== "project_skills_v1"
-        && capability !== "agent_ability_release_v1"
-        && capability !== "agent_ability_workspace_v1"
-        && capability !== "agent_ability_runtime_assets_v1");
+]);
+export const daemonCapabilities = (runtimePlatform = process.platform, readiness = NATIVE_PROJECT_WORKSPACE_READINESS) => {
+    // Windows stays fail-closed until the native workspace adapter gate is verified on a real host.
+    const nativeWorkspacePlatform = runtimePlatform === "darwin" || runtimePlatform === "linux";
+    const nativeWorkspaceReady = nativeWorkspacePlatform
+        && readiness.resolverReady
+        && readiness.nativeRuntimeAdaptersReady;
+    return Object.freeze(DAEMON_CAPABILITIES.filter((capability) => ((capability !== PROJECT_WORKSPACES_CAPABILITY || nativeWorkspaceReady)
+        && (nativeWorkspacePlatform
+            || (capability !== "project_skills_v1"
+                && capability !== "agent_ability_release_v1"
+                && capability !== "agent_ability_workspace_v1"
+                && capability !== "agent_ability_runtime_assets_v1")))));
+};
+export const daemonCapabilityBindings = (runtimePlatform = process.platform, injectedCapabilities) => {
+    const snapshot = injectedCapabilities === undefined
+        ? daemonCapabilities(runtimePlatform)
+        : Object.freeze([...injectedCapabilities]);
+    return Object.freeze({
+        controlPlaneUrl: snapshot,
+        machineHello: snapshot,
+        executionRunner: snapshot,
+    });
+};
 export const EXECUTION_PROTOCOL = Object.freeze({ min: 1, max: 1 });
 /** 候选 runtime CLI:展示名 → 可执行文件名。 */
 const RUNTIME_BINS = [
@@ -152,7 +176,19 @@ export async function collectMachineHello(agentsRoot, executionLimits, runtimePl
         daemonVersion: daemonVersion(),
         runtimes,
         executionRuntimes,
-        capabilities: [...daemonCapabilities(runtimePlatform), ...additionalCapabilities],
+        capabilities: Object.freeze([
+            ...(dependencies.capabilities ?? daemonCapabilities(runtimePlatform)),
+            ...additionalCapabilities,
+        ]),
+        ...(dependencies.profileName === undefined ? {} : {
+            layoutVersion: 1,
+            profileName: dependencies.profileName,
+            daemonHome: dependencies.daemonHome ?? daemonHome(),
+            agentsRoot,
+            ...(dependencies.profileName.match(/^nw-(?:in|dev)-([a-z0-9][a-z0-9_-]{0,39})$/u)?.[1] === undefined
+                ? {}
+                : { localInstanceName: dependencies.profileName.match(/^nw-(?:in|dev)-([a-z0-9][a-z0-9_-]{0,39})$/u)[1] }),
+        }),
         ...(backend.supported ? {
             executionProtocol: EXECUTION_PROTOCOL,
             executionLimits: Object.freeze({

package/dist/normalize.js

@@ -4,6 +4,7 @@
  * 这是 daemon 的关键职责:前端/server 看到的是"在读历史/领任务/发消息",而非裸 Bash。
  * 纯函数,无 IO,完整单测。
  */
+import { boundedCodexPlan, codexPlanText } from "./runtimes/codex-contract.js";
 /**
  * Strip /bin/zsh -lc, /bin/sh -c, or /bin/bash -lc shell wrappers (single OR double quotes),
  * including multi-line heredoc forms. [\s\S]+ matches across newlines. Backreference \1 ensures
@@ -63,6 +64,10 @@ function parseKimiBashCommand(args) {
 /** 把一个 stream-json 事件归一化为 0..N 个活动。 */
 export function normalizeEvent(event) {
     const e = (event ?? {});
+    if (e.type === "turn.plan.updated") {
+        const plan = boundedCodexPlan(e.plan);
+        return plan === null ? [] : [{ kind: "tool", label: "计划更新", detail: codexPlanText(plan) }];
+    }
     if ((e.type === "kimi.acp.text_delta" || e.type === "hermes.acp.text_delta"
         || e.type === "deepseek-harness.acp.text_delta"
         || e.type === "opencode.text_delta") && e.text?.trim()) {