@nowcrew/daemon 0.6.68 → 0.6.70

package/dist/console.js

@@ -17,7 +17,7 @@ import { buildFilePreview, buildSnippetDiff } from "./console-payload.js";
 import { parseUnifiedDiff } from "./unified-diff.js";
 import { buildJsonResult } from "./json-result.js";
 import { buildCollapsedResult } from "./console-collapse.js";
-import { boundedCodexPlan, codexPlanText } from "./runtimes/codex-contract.js";
+import { boundedCodexPlan } from "./runtimes/codex-contract.js";
 /** 单条工具返回正文上限(超出截断并标注),避免单条把终端/DB 撑爆。 */
 export const TOOL_RESULT_CAP = 4000;
 /** 工具输入摘要上限(标题行那一段)。 */
@@ -69,6 +69,12 @@ function summarizeToolInput(name, input) {
         .join(", ");
     return `⏺ ${name}(${clip(head.replace(/\s+/g, " "), TOOL_INPUT_CAP)})`;
 }
+/** codex 计划步骤状态(pending/inProgress/completed) → ConsoleTodo 状态(pending/in_progress/completed)。 */
+const CODEX_PLAN_STATUS_MAP = {
+    pending: "pending",
+    inProgress: "in_progress",
+    completed: "completed",
+};
 const TODO_STATUSES = new Set(["pending", "in_progress", "completed"]);
 /** claude TodoWrite 的 todos 数组归一为 ConsoleTodo[](脏数据条目丢弃)。 */
 function normalizeTodos(raw) {
@@ -236,7 +242,13 @@ function codexItemChunks(item, td) {
         if (!todos.length)
             return [];
         const done = todos.filter((t) => t.status === "completed").length;
-        return [{ stream: "tool", text: `⏺ Todos(${done}/${todos.length})`, payload: { kind: "todos", todos } }];
+        // codex 对同一份 plan 的多次更新复用同一个 item.id,透传给下游做合并键;无 id 时不伪造。
+        const listId = typeof item.id === "string" && item.id ? item.id : undefined;
+        return [{
+                stream: "tool",
+                text: `⏺ Todos(${done}/${todos.length})`,
+                payload: { kind: "todos", todos, ...(listId ? { listId } : {}) },
+            }];
     }
     if (item.type === "web_search" && item.query?.trim()) {
         return [{ stream: "tool", text: `⏺ WebSearch(${clip(item.query.trim(), TOOL_INPUT_CAP)})` }];
@@ -276,10 +288,17 @@ export function toConsoleLines(event) {
     }
     if (e.type === "turn.plan.updated") {
         const plan = boundedCodexPlan(e.plan);
-        return plan === null ? [] : [{
+        if (plan === null)
+            return [];
+        const todos = plan.map(({ step, status }) => ({
+            text: step,
+            status: CODEX_PLAN_STATUS_MAP[status],
+        }));
+        const listId = typeof e.turn_id === "string" && e.turn_id ? e.turn_id : "codex-plan";
+        return [{
                 stream: "tool",
                 text: `⏺ ${td("Plan updated")} (${plan.length})`,
-                payload: { kind: "plan", plan: codexPlanText(plan) },
+                payload: { kind: "todos", todos, listId },
             }];
     }
     if (e.type === "item.completed" && e.item) {

package/dist/daemon-migration-controller.js

@@ -10,6 +10,7 @@ import { buildServiceSpec, captureExactService, serviceStatus, systemCommandRunn
 import { readManagedServiceRegistry } from "./managed-service-registry.js";
 import { uninstallManagedService } from "./managed-service-lifecycle.js";
 import { resolveAutomaticInstallTarget } from "./automatic-install-target.js";
+import { buildStorageMigrationMappings, createSafeServiceManifest, CredentialMaterialError, } from "./storage-migration-manifest.js";
 const MigrationMessageSchema = z.object({
     type: z.literal("daemon:migrate"),
     migrationId: z.string().uuid(),
@@ -47,33 +48,30 @@ async function hashedFiles(root, directory = root) {
     return files;
 }
 async function backupAndCopy(input, id, targetHome, targetAgents, service) {
+    // Validate and project service identity before creating any backup bytes. A descriptor containing
+    // a token must stop the migration before it can be copied into the local backup root.
+    const safeService = createSafeServiceManifest({
+        spec: service.spec,
+        snapshot: service.snapshot,
+        managedRecord: service.managedRecord,
+    });
     const backup = migrationBackupRoot(input, id);
     await mkdir(backup, { recursive: true, mode: 0o700 });
     await cp(input.currentDaemonHome, resolve(backup, "daemon-home"), { recursive: true, force: false });
     await cp(input.currentAgentsRoot, resolve(backup, "agents-root"), { recursive: true, force: false });
     await cp(input.currentDaemonHome, targetHome, { recursive: true, force: false });
     await cp(input.currentAgentsRoot, targetAgents, { recursive: true, force: false });
-    const files = [
-        ...(await hashedFiles(resolve(backup, "daemon-home"))).map((file) => ({ ...file, path: `daemon-home/${file.path}` })),
-        ...(await hashedFiles(resolve(backup, "agents-root"))).map((file) => ({ ...file, path: `agents-root/${file.path}` })),
-    ];
+    const daemonFiles = await hashedFiles(resolve(backup, "daemon-home"));
+    const agentFiles = await hashedFiles(resolve(backup, "agents-root"));
+    const mappings = buildStorageMigrationMappings({ daemonFiles, agentFiles });
     await writeFile(resolve(backup, "manifest.json"), `${JSON.stringify({
-        version: 1,
+        version: 2,
         migrationId: id,
         profile: input.profileName,
         daemonHome: input.currentDaemonHome,
         agentsRoot: input.currentAgentsRoot,
-        service: {
-            id: service.spec.id,
-            platform: service.spec.platform,
-            descriptorPath: service.spec.descriptorPath,
-            descriptor: service.spec.descriptor,
-            daemonCommand: service.spec.daemonCommand,
-            installed: service.snapshot.installed,
-            running: service.snapshot.running,
-            managedRecord: service.managedRecord,
-        },
-        files,
+        service: safeService,
+        mappings,
     }, null, 2)}\n`, { mode: 0o600 });
     return backup;
 }
@@ -147,7 +145,7 @@ export function createDaemonMigrationController(input) {
                 }
             }
             catch (error) {
-                sendFailure(message.migrationId, "target_conflict", error);
+                sendFailure(message.migrationId, error instanceof CredentialMaterialError ? "credential_material" : "target_conflict", error);
                 return;
             }
             input.sendStatus({ type: "daemon:migration-status", migrationId: message.migrationId, status: "backing_up" });
@@ -158,7 +156,7 @@ export function createDaemonMigrationController(input) {
             }
             catch (error) {
                 await Promise.allSettled([rm(targetPath, { recursive: true, force: true }), rm(targetAgents, { recursive: true, force: true })]);
-                sendFailure(message.migrationId, "backup_failed", error);
+                sendFailure(message.migrationId, error instanceof CredentialMaterialError ? "credential_material" : "backup_failed", error);
                 return;
             }
             const install = input.install ?? installDaemonAutomatically;

package/dist/execution-protocol.js

@@ -197,7 +197,6 @@ export const ExecutionStartSchema = z.object({
         language: z.enum(["zh", "en"]),
         systemPrompt: z.string(),
         wakePrompt: z.string(),
-        maintenancePurpose: z.literal("self_training").optional(),
     }).strict(),
     runtime: z.object({
         name: RuntimeSchema,

package/dist/execution-runner.js

@@ -19,6 +19,7 @@ import { ProjectSkillRuntimeOwnershipUnverifiedError, } from "./project-skills/r
 import { projectSkillExecutionProjection, projectSkillProjectionErrorCode } from "./project-skills/execution-adapter.js";
 import { redactProjectSkillRuntimeRootError, } from "./project-skills/runtime-launch.js";
 import { createProjectRegistry } from "./project-skills/registry.js";
+import { ProjectDependencyError, } from "./project-dependencies.js";
 import { ProjectContextUnavailableError, resolveProjectContext } from "./project-workspaces/resolver.js";
 import { PROJECT_WORKSPACES_CAPABILITY } from "./machine-info.js";
 import { PROJECT_SKILL_PROJECTION_V2_CAPABILITY } from "./project-skills/types.js";
@@ -315,7 +316,9 @@ function failedCompletion(spec, error, startedAt, finishedAt) {
         ? "queue_timeout"
         : error instanceof ProjectContextUnavailableError
             ? error.code
-            : projectSkillProjectionErrorCode(error) ?? "local_execution_failed";
+            : error instanceof ProjectDependencyError
+                ? error.code
+                : projectSkillProjectionErrorCode(error) ?? "local_execution_failed";
     return ExecutionCompletedSchema.parse({
         type: "execution:completed",
         protocolVersion: 1,
@@ -503,21 +506,68 @@ export async function runExecution(config, input, dependencies) {
             await cancellable(dependencies.slot.ready, dependencies.cancellation);
         }
         let projectContext;
+        let trainingProjectContext;
         let sessionContextFingerprint;
         const logicalProjectContext = spec.workspace.projectContext;
-        if (logicalProjectContext !== undefined && logicalProjectContext.projectIds.length > 0) {
+        dslog("project_dependencies.preflight", "项目依赖准备前置状态", {
+            execution_id: spec.executionId,
+            agent_handle: spec.agent.handle,
+            has_ability_release: spec.agent.abilityRelease !== undefined,
+            ability_release_id: spec.agent.abilityRelease?.releaseId,
+            ability_root_commit: spec.agent.abilityRelease?.rootCommit,
+            has_project_context: logicalProjectContext !== undefined,
+            project_ids: JSON.stringify(logicalProjectContext?.projectIds ?? []),
+            project_context_primary: logicalProjectContext?.primaryProjectId,
+            dependency_prepare_expected: spec.agent.abilityRelease !== undefined,
+        });
+        if (spec.agent.abilityRelease !== undefined && dependencies.projectDependencies !== undefined) {
+            if (dependencies.abilityRelease !== undefined) {
+                await cancellable(dependencies.abilityRelease.apply(config.agentsRoot, spec.agent.handle, spec.agent.abilityRelease), dependencies.cancellation);
+            }
+            const preparedProjectDependencies = await cancellable(dependencies.projectDependencies.prepare({
+                trainingRoot: join(config.agentsRoot, spec.agent.handle, "training"),
+                reposRoot: join(config.agentsRoot, "repos"),
+                lockRoot: join(config.agentsRoot, ".crew", "project-dependencies"),
+            }), dependencies.cancellation);
+            trainingProjectContext = Object.freeze({
+                projects: Object.freeze(preparedProjectDependencies.map((project) => Object.freeze({
+                    repositoryKey: project.repositoryKey,
+                    displayName: project.displayName,
+                    repo: project.repo,
+                    root: project.localRoot,
+                    branch: project.branch,
+                    resolvedCommit: project.resolvedCommit,
+                }))),
+            });
+            for (const project of preparedProjectDependencies) {
+                dslog("project_dependencies.prepared", "Training project dependency prepared", {
+                    execution_id: spec.executionId,
+                    agent_handle: spec.agent.handle,
+                    repository_key: project.repositoryKey,
+                    project_branch: project.branch,
+                    project_branch_source: project.branchSource,
+                    project_commit: project.resolvedCommit,
+                    project_checkout_mode: project.checkoutMode,
+                });
+            }
+        }
+        else if (spec.agent.abilityRelease === undefined
+            && 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);
+            const projectWorkspaceRegistry = dependencies.projectWorkspaceRegistry
+                ?? dependencies.projectRegistry
+                ?? createProjectRegistry(config.agentsRoot);
+            projectContext = await cancellable(resolveProjectContext(projectSnapshot, projectWorkspaceRegistry), dependencies.cancellation);
             sessionContextFingerprint = projectSessionContextFingerprint(spec.runtime.name, projectSnapshot);
         }
-        const selfTraining = spec.instructions.maintenancePurpose === "self_training";
         let recalledMemory = "";
-        if (!selfTraining && spec.agent.memoryEnabled === true && dependencies.agentMemory !== undefined) {
+        if (spec.agent.memoryEnabled === true && dependencies.agentMemory !== undefined) {
             try {
                 recalledMemory = await cancellable(dependencies.agentMemory.recall(spec.agent.handle, spec.instructions.wakePrompt, spec.executionId, spec.agent.memoryAgentId ?? null), dependencies.cancellation);
             }
@@ -776,9 +826,7 @@ export async function runExecution(config, input, dependencies) {
         const baseSystemPromptBudget = spec.agent.abilityRelease === undefined
             ? systemPromptBudget
             : Math.max(0, Math.min(systemPromptBudget, Math.max(32 * 1024, systemPromptBudget - 168 * 1024)));
-        const systemPromptWithLocalFacts = withLocalExecutionFacts(spec.instructions.systemPrompt, baseSystemPromptBudget, {
-            ...(selfTraining ? { isolateLocalMemory: true } : {}),
-        });
+        const systemPromptWithLocalFacts = withLocalExecutionFacts(spec.instructions.systemPrompt, baseSystemPromptBudget, { collaborationTools: config.codexCollaborationTools && spec.runtime.name === "codex" });
         const boundedSystemPrompt = (context) => appendAgentMemoryContext(typeof systemPromptWithLocalFacts === "string"
             ? systemPromptWithLocalFacts
             : systemPromptWithLocalFacts(context), recalledMemory, baseSystemPromptBudget);
@@ -791,6 +839,7 @@ export async function runExecution(config, input, dependencies) {
             ...(spec.workspace.resumeKey === undefined ? {} : { resumeKey: spec.workspace.resumeKey }),
             ...(sessionContextFingerprint === undefined ? {} : { sessionContextFingerprint }),
             ...(projectContext === undefined ? {} : { projectContext }),
+            ...(trainingProjectContext === undefined ? {} : { trainingProjectContext }),
             ...(spec.context.wakeMessageId === undefined ? {} : { wakeMessageId: spec.context.wakeMessageId }),
             ...(spec.context.attachments === undefined ? {} : { attachments: spec.context.attachments }),
             ...(spec.agent.projectSkills === undefined
@@ -804,6 +853,7 @@ export async function runExecution(config, input, dependencies) {
                 name: spec.runtime.name,
                 ...(spec.runtime.model === undefined ? {} : { model: spec.runtime.model }),
                 ...(spec.runtime.reasoning === undefined ? {} : { reasoning: spec.runtime.reasoning }),
+                codexCollaborationTools: config.codexCollaborationTools,
             },
             effectivePermission: permission,
             captureFinal: spec.reporting.captureFinal,
@@ -823,13 +873,13 @@ export async function runExecution(config, input, dependencies) {
                 } : {}),
             },
             session: {
-                enabled: selfTraining ? false : config.resume,
+                enabled: config.resume,
                 warmMs: config.resumeWarmMs,
                 budgetTokens: config.sessionBudgetTokens,
                 softTokens: config.sessionSoftTokens,
                 maxTurns: config.sessionMaxTurns,
             },
-            ...(selfTraining ? { maintenancePurpose: "self_training" } : {}),
+            localMemoryV2Enabled: config.localMemoryV2Handles?.has(spec.agent.handle) === true,
         };
         const result = await Promise.race([
             execute(localInput, callbacks, localDependencies),
@@ -995,7 +1045,6 @@ export async function runExecution(config, input, dependencies) {
     }
     await dependencies.journal.complete(spec.executionId, completion);
     if (completion.outcome === "succeeded"
-        && spec.instructions.maintenancePurpose !== "self_training"
         && spec.agent.memoryEnabled === true
         && memoryCaptureFinalText !== null
         && dependencies.agentMemory !== undefined) {

package/dist/i18n.js

@@ -19,6 +19,8 @@ const zh = {
     "Claude session started": "Claude 会话启动",
     "Codex session started": "Codex 会话启动",
     "Plan updated": "计划更新",
+    "Thinking (~{{tokens}} tokens, content not streamed by Claude Code)": "思考（约 {{tokens}} tokens，Claude Code 未输出思考正文）",
+    "Thinking (content not streamed by Claude Code)": "思考（Claude Code 未输出思考正文）",
     "Files changed": "文件变更",
     "Run failed": "运行出错",
     "Run finished": "本轮结束",

package/dist/local-execution-prompt.js

@@ -4,7 +4,22 @@
  * server 提示词是权威部分,绝不裁剪;项目工作区提示词是绑定执行的强制部分,放不下就直接失败;
  * 只有本机事实(CREW_HOME / work-log / MEMORY 注入)是可选增强,按整段丢弃或按字节截断。
  */
-import { buildRuntimeWorkspacePrompt, capMemoryForInject, capWorkLogForInject, } from "./prompt.js";
+import { buildCollaborationToolsPrompt, buildRuntimeWorkspacePrompt, capMemoryForInject, capWorkLogForInject, } from "./prompt.js";
+const trainingProjectJson = (project) => JSON.stringify({
+    repositoryKey: project.repositoryKey,
+    displayName: project.displayName,
+    repo: project.repo,
+    branch: project.branch,
+    resolvedCommit: project.resolvedCommit,
+    root: project.root,
+});
+export function buildTrainingGitProjectPrompt(context) {
+    if (context === undefined || context.projects.length === 0)
+        return "";
+    return "\n\n## Training Git projects\n" + context.projects
+        .map((project) => "- " + trainingProjectJson(project) + "\n  Run project commands with: cd <root> && <command>")
+        .join("\n");
+}
 export function truncateUtf8(value, maxBytes) {
     if (maxBytes <= 0)
         return "";
@@ -31,28 +46,32 @@ function takeCompletePromptSections(sections, maxBytes) {
 }
 /** v1 server instructions opt in to daemon-owned paths and bounded local workspace context. */
 export function withLocalExecutionFacts(serverPrompt, maxBytes, options = {}) {
-    return ({ workspace, resuming, projectContext }) => {
-        const memory = options.isolateLocalMemory ? "" : capMemoryForInject(workspace.memory);
+    return ({ workspace, resuming, projectContext, trainingProjectContext }) => {
+        const memory = capMemoryForInject(workspace.memory);
         const workLog = resuming ? "" : capWorkLogForInject(workspace.workLog);
-        const mandatoryWorkspacePrompt = buildRuntimeWorkspacePrompt(projectContext);
-        const crewHome = options.isolateLocalMemory ? workspace.runDir : workspace.dir;
+        const collaborationPrompt = options.collaborationTools === true ? buildCollaborationToolsPrompt() : "";
+        const mandatoryWorkspacePrompt = `${buildRuntimeWorkspacePrompt(projectContext)}${buildTrainingGitProjectPrompt(trainingProjectContext)}`;
         const localFactSections = [`\n\n## Local execution facts
-- $CREW_HOME: ${crewHome}
+- $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("");
+        const serverPromptBytes = Buffer.byteLength(serverPrompt, "utf8");
+        const collaborationBytes = Buffer.byteLength(collaborationPrompt, "utf8");
+        const mandatoryBytes = Buffer.byteLength(mandatoryWorkspacePrompt, "utf8");
+        const requiredBytes = serverPromptBytes + collaborationBytes + mandatoryBytes;
+        // 必需预算与 projectContext 无关:协作段落永远参与;无协作时与旧实现逐字节等价。
+        if (collaborationPrompt !== "" && requiredBytes > maxBytes) {
+            throw new Error("collaboration_tools_prompt_budget_exceeded");
+        }
         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}`;
+            return `${serverPrompt}${collaborationPrompt}${optionalFacts}${mandatoryWorkspacePrompt}`;
         }
-        const remaining = maxBytes - Buffer.byteLength(serverPrompt, "utf8");
-        return `${serverPrompt}${truncateUtf8(localFacts, remaining)}`;
+        const remaining = maxBytes - requiredBytes;
+        return `${serverPrompt}${collaborationPrompt}${truncateUtf8(localFactSections.join(""), remaining)}`;
     };
 }