@nowcrew/daemon 0.6.67 → 0.6.69

package/dist/agent-ability/materializer.js

@@ -470,6 +470,7 @@ const materializeWorkspaceTraining = async (agentsRoot, handle, ability) => {
     const projectionDigest = abilitySha256(JSON.stringify({
         artifactDigest: ability.artifactDigest,
         workspace: ability.workspace,
+        git: verified.manifest.spec.git ?? null,
     }));
     let previousCatalog = null;
     if (await exists(trainingRoot)) {
@@ -531,6 +532,12 @@ const materializeWorkspaceTraining = async (agentsRoot, handle, ability) => {
                 : join(sourceRoot, asset.source);
             await cp(source, target, { recursive: true, preserveTimestamps: true });
         }
+        const gitManifestPath = verified.manifest.spec.git?.projectDependencies.path;
+        if (gitManifestPath !== undefined) {
+            const target = join(staging, "git", layerRelativePath(gitManifestPath, "git"));
+            await mkdir(dirname(target), { recursive: true });
+            await cp(join(sourceRoot, gitManifestPath), target, { preserveTimestamps: true });
+        }
         const evalPaths = [
             ...(verified.manifest.spec.evals.policy === undefined ? [] : [verified.manifest.spec.evals.policy]),
             ...verified.manifest.spec.evals.cases,
@@ -553,6 +560,9 @@ const materializeWorkspaceTraining = async (agentsRoot, handle, ability) => {
                 ...asset,
                 projectedPath: `training/workspace/${abilityWorkspaceProjectionPath(asset.target)}`,
             })),
+            git: gitManifestPath === undefined ? null : {
+                projectDependenciesPath: `training/git/${layerRelativePath(gitManifestPath, "git")}`,
+            },
             evals: evalPaths.map((path) => `training/evals/${layerRelativePath(path, "evals")}`),
         }, null, 2), { encoding: "utf8", mode: 0o600 });
         await readonlyTree(staging, { rootWritable: true });

package/dist/agent-ability/resolver.js

@@ -7,6 +7,7 @@ import { parse } from "yaml";
 import { z } from "zod";
 import { abilityWorkspaceProjectionPath, DaemonAbilityLockSchema, DaemonAbilityManifestSchema, matchesAbilityBranch, } from "./types.js";
 import { PROJECT_MANIFEST_SOURCE_PATH, ProjectDependencyManifestSchema, } from "../project-dependency-manifest.js";
+import { normalizeRepositoryIdentity } from "../repository-identity.js";
 const runFile = promisify(execFile);
 const MAX_FILES = 5_000;
 const MAX_TOTAL_BYTES = 25 * 1024 * 1024;
@@ -78,20 +79,30 @@ const git = async (args, cwd) => {
     return result.stdout.trim();
 };
 export const projectDependencyIds = (files, manifest) => {
-    const assets = manifest.spec.workspace.assets.filter((asset) => asset.source === PROJECT_MANIFEST_SOURCE_PATH);
-    if (assets.length === 0)
+    const path = manifest.spec.git?.projectDependencies.path;
+    if (path === undefined)
         return Object.freeze([]);
-    if (assets.length > 1)
-        throw new Error("ability_project_dependency_manifest_duplicate");
-    const file = files.find((candidate) => candidate.path === PROJECT_MANIFEST_SOURCE_PATH);
+    if (path !== PROJECT_MANIFEST_SOURCE_PATH)
+        throw new Error("ability_project_dependency_manifest_path_invalid");
+    const file = files.find((candidate) => candidate.path === path);
     if (file === undefined)
         throw new Error("ability_project_dependency_manifest_missing");
+    let projects;
     try {
-        return Object.freeze(ProjectDependencyManifestSchema.parse(parse(file.content.toString("utf8"))).projects.map((project) => project.id));
+        projects = ProjectDependencyManifestSchema.parse(parse(file.content.toString("utf8"))).projects;
     }
     catch {
         throw new Error("ability_project_dependency_manifest_invalid");
     }
+    return Object.freeze(projects.map((project) => {
+        try {
+            validateAbilityGitHost(project.repo);
+        }
+        catch {
+            throw new Error("ability_project_dependency_host_not_allowed");
+        }
+        return normalizeRepositoryIdentity(project.repo).repositoryKey;
+    }));
 };
 export const collectAbilityFiles = async (root) => {
     const files = [];
@@ -285,6 +296,8 @@ const scan = (files, manifest) => {
         required.add("memory-seed");
     if (manifest.spec.workspace.assets.length > 0)
         required.add("workspace");
+    if (manifest.spec.git !== undefined)
+        required.add("git");
     if (manifest.spec.evals.policy !== undefined)
         required.add("eval-policy");
     if (manifest.spec.evals.cases.length > 0)
@@ -297,6 +310,7 @@ const lockedManifestPaths = (manifest) => [
     ...manifest.spec.memory.policy.map((entry) => entry.path),
     ...manifest.spec.memory.seeds.map((entry) => entry.path),
     ...manifest.spec.workspace.assets.map((entry) => entry.source),
+    ...(manifest.spec.git === undefined ? [] : [manifest.spec.git.projectDependencies.path]),
     ...(manifest.spec.evals.policy === undefined ? [] : [manifest.spec.evals.policy]),
     ...manifest.spec.evals.cases,
 ];

package/dist/agent-ability/types.js

@@ -19,7 +19,7 @@ export const AbilityRepositoryUrlSchema = z.string().trim().min(1).max(2_048).su
     try {
         const url = new URL(value);
         allowedUrl = (url.protocol === "https:" || url.protocol === "ssh:")
-            && !url.username && !url.password && Boolean(url.hostname);
+            && !url.username && !url.password && !url.search && !url.hash && Boolean(url.hostname);
     }
     catch { /* handled below */ }
     if (!scpLike && !allowedUrl)
@@ -53,6 +53,10 @@ const LocalSkillSchema = z.object({ type: z.literal("local"), path: SafeAbilityP
 const GitSkillSchema = z.object({
     type: z.literal("git"), url: AbilityRepositoryUrlSchema, ref: z.string().min(1).max(256), path: SafeAbilityPathSchema,
 }).strict();
+const GitProjectDependencyPathSchema = z.literal("git/project-dependencies.yaml");
+const GitLayerSchema = z.object({
+    projectDependencies: z.object({ path: GitProjectDependencyPathSchema }).strict(),
+}).strict();
 export const DaemonAbilityManifestSchema = z.object({
     apiVersion: z.literal("nowcrew.ai/v1alpha1"), kind: z.literal("AgentTraining"),
     metadata: z.object({ name: z.string().min(1).max(128), version: z.string().min(1).max(64), description: z.string().max(1_000).optional() }).strict(),
@@ -71,6 +75,7 @@ export const DaemonAbilityManifestSchema = z.object({
         workspace: z.object({ assets: z.array(z.object({
                 source: SafeAbilityPathSchema, target: WorkspaceAbilityTargetSchema, mode: ModeSchema,
             }).strict()).max(1_000).default([]) }).strict().default({ assets: [] }),
+        git: GitLayerSchema.optional(),
         evals: z.object({
             policy: SafeAbilityPathSchema.optional(),
             cases: z.array(SafeAbilityPathSchema).max(1_000).default([]),
@@ -95,16 +100,6 @@ export const DaemonAbilityManifestSchema = z.object({
     unique(manifest.spec.skills.map((skill) => skill.name.replace(/[^A-Za-z0-9._-]/gu, "_")), ["spec", "skills"], "Skill projection");
     unique(manifest.spec.skills.map((skill) => skill.mount), ["spec", "skills"], "Skill mount");
     unique(manifest.spec.workspace.assets.map((asset) => asset.target), ["spec", "workspace", "assets"], "Workspace target");
-    for (const asset of manifest.spec.workspace.assets) {
-        if (asset.source === "workspace/project-dependencies.yaml"
-            && asset.target !== "training/workspace/project-dependencies.yaml") {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                path: ["spec", "workspace", "assets"],
-                message: "project dependency manifest target must be training/workspace/project-dependencies.yaml",
-            });
-        }
-    }
     unique(manifest.spec.evals.cases, ["spec", "evals", "cases"], "Eval case");
 });
 export const DaemonAbilityLockSchema = z.object({

package/dist/background-job.js

@@ -0,0 +1,50 @@
+/**
+ * Claude 后台任务(Bash run_in_background + TaskOutput 轮询)的结果解析。纯函数,零 IO。
+ *
+ * TaskOutput 的 tool_result 是 XML 式文本,实测形状见
+ * docs/superpowers/evidence/2026-08-22-claude-background-task-stream-json.json。
+ * 注意轮询工具是 TaskOutput 而非 BashOutput——claude 2.1.238 实测确认。
+ */
+/** 输出正文的字符上限,与 console 其它工具返回保持同量级。 */
+const OUTPUT_CAP = 4000;
+const tag = (text, name) => {
+    const match = new RegExp(`<${name}>([\\s\\S]*?)</${name}>`, "u").exec(text);
+    return match ? match[1].trim() : undefined;
+};
+/**
+ * <output> 是协议里的最后一段,正文本身(命令的 stdout)可能包含字面量的 "</output>"
+ * (例如打印了一份 XML/日志)。非贪婪匹配会在第一个 "</output>" 处截断,把后面的真实内容
+ * 静默丢掉,产出一个"看起来对但其实错"的结果。这里改为贪婪匹配,吞到文本中*最后一个*
+ * "</output>",与协议里 output 恒为末段的事实对齐。
+ */
+const extractOutputTag = (text) => {
+    const match = /<output>([\s\S]*)<\/output>/u.exec(text);
+    return match ? match[1].trim() : undefined;
+};
+export function parseTaskOutput(text) {
+    const jobId = tag(text, "task_id");
+    if (!jobId)
+        return null;
+    const status = tag(text, "status");
+    if (!status)
+        return null;
+    const rawExit = tag(text, "exit_code");
+    const exitCode = rawExit !== undefined && /^-?\d+$/u.test(rawExit) ? Number(rawExit) : undefined;
+    // status 只要不是 running,就按已结束处理(completed/failed/killed 等都归入 exited)。
+    const state = status === "running" ? "running" : "exited";
+    const rawOutput = extractOutputTag(text);
+    return {
+        jobId,
+        state,
+        ...(exitCode !== undefined ? { exitCode } : {}),
+        // lineCount 必须基于截断前的完整正文——否则前端拿到的"总行数"其实是预览的行数,
+        // 无法用来判断是否还有更多内容可展开(参照 console.ts 里 buildScriptResult 的做法)。
+        ...(rawOutput
+            ? {
+                output: rawOutput.slice(0, OUTPUT_CAP),
+                lineCount: rawOutput.split("\n").length,
+                ...(rawOutput.length > OUTPUT_CAP ? { truncated: true } : {}),
+            }
+            : {}),
+    };
+}

package/dist/console-formatter.js

@@ -3,11 +3,13 @@
  * 用 tool_use id 关联 Read 结果,避免将整文件作为普通 tool_result 倾泻到终端。
  */
 import { buildFilePreview } from "./console-payload.js";
+import { detectDaemonLang, formatDaemonText, translateDaemon } from "./i18n.js";
 import { buildScriptResult, toConsoleLines, TOOL_RESULT_CAP } from "./console.js";
 import { parseUnifiedDiff } from "./unified-diff.js";
 import { buildJsonResult } from "./json-result.js";
 import { buildCollapsedResult } from "./console-collapse.js";
 import { buildSkillPreview } from "./skill-preview.js";
+import { parseTaskOutput } from "./background-job.js";
 const extract = (content) => {
     if (typeof content === "string")
         return content;
@@ -22,16 +24,71 @@ const clip = (text) => text.length > TOOL_RESULT_CAP
 const SCRIPT_TOOLS = new Set(["Bash", "PowerShell", "Shell"]);
 export function createConsoleFormatter() {
     const pending = new Map();
+    // listId → 上一条 todos 快照的指纹;仅用于丢弃「连续两次完全相同」的重复事件(无损去重)。
+    // 只比对相邻快照,不做跨快照合并——进度推进的中间态必须逐条下发,否则前端进度条会停在旧值。
+    const lastTodoFingerprint = new Map();
+    // jobId → 已下发次数(去重后);后台任务在滚动流里折叠成一个单元,次数供前端展示。
+    // 与去重表联动:被丢弃的重复轮询不会走到这里递增,所以计的是"不同状态数"而非"原始轮询数"。
+    const jobPollCount = new Map();
+    // jobId → 上一条轮询结果的指纹,用于丢弃「连续两次完全相同」的轮询(无损去重)。
+    const lastJobFingerprint = new Map();
+    /** 丢弃与该 listId 上一条完全相同的 todos 行;无 listId 的不参与去重。 */
+    const dedupeTodos = (chunks) => chunks.filter((chunk) => {
+        const payload = chunk.payload;
+        if (!payload || payload.kind !== "todos" || !payload.listId)
+            return true;
+        const fingerprint = JSON.stringify(payload.todos);
+        if (lastTodoFingerprint.get(payload.listId) === fingerprint)
+            return false;
+        lastTodoFingerprint.set(payload.listId, fingerprint);
+        return true;
+    });
+    // claude redacted-thinking(redact-thinking-2026-02-12):流式阶段 thinking_delta.thinking 为空串,
+    // 只携带 estimated_tokens 估算(数值会被修正,取最新值);完整 assistant 消息里 thinking 也为空。
+    // 这里累积估算值,在 assistant 消息落地时把空 thinking 块补成占位文本;
+    // 若未来 CLI 恢复明文思考,累积到的正文优先生效,占位逻辑自动失效。
+    let pendingThinking = null;
+    const consumePendingThinking = () => {
+        if (!pendingThinking)
+            return null;
+        const { text, tokens } = pendingThinking;
+        pendingThinking = null;
+        if (text.trim())
+            return text.trim();
+        const lang = detectDaemonLang();
+        return tokens > 0
+            ? formatDaemonText(lang, "Thinking (~{{tokens}} tokens, content not streamed by Claude Code)", { tokens })
+            : translateDaemon(lang, "Thinking (content not streamed by Claude Code)");
+    };
     return {
         format(event) {
             const rec = event && typeof event === "object" ? event : {};
             const message = rec.message && typeof rec.message === "object" ? rec.message : undefined;
+            if (rec.type === "stream_event" && rec.event && typeof rec.event === "object") {
+                const streamEvent = rec.event;
+                if (streamEvent.type === "content_block_delta" && streamEvent.delta?.type === "thinking_delta") {
+                    const prev = pendingThinking ?? { text: "", tokens: 0 };
+                    pendingThinking = {
+                        text: prev.text + (typeof streamEvent.delta.thinking === "string" ? streamEvent.delta.thinking : ""),
+                        tokens: typeof streamEvent.delta.estimated_tokens === "number" ? streamEvent.delta.estimated_tokens : prev.tokens,
+                    };
+                }
+                return [];
+            }
             if (rec.type === "assistant" && Array.isArray(message?.content)) {
                 for (const block of message.content) {
                     if (block.type === "tool_use" && block.id && block.name) {
                         pending.set(block.id, { name: block.name, ...(block.input ? { input: block.input } : {}) });
                     }
                 }
+                const hasEmptyThinking = message.content.some((block) => block.type === "thinking" && !block.thinking?.trim());
+                if (hasEmptyThinking) {
+                    const filler = consumePendingThinking();
+                    if (filler) {
+                        const content = message.content.map((block) => block.type === "thinking" && !block.thinking?.trim() ? { ...block, thinking: filler } : block);
+                        return dedupeTodos(toConsoleLines({ ...rec, message: { ...message, content } }));
+                    }
+                }
             }
             if (rec.type === "user" && Array.isArray(message?.content)) {
                 const out = [];
@@ -44,6 +101,24 @@ export function createConsoleFormatter() {
                     const tool = block.tool_use_id ? pending.get(block.tool_use_id) : undefined;
                     if (block.tool_use_id)
                         pending.delete(block.tool_use_id);
+                    if (!block.is_error && tool?.name === "TaskOutput") {
+                        const parsed = parseTaskOutput(text);
+                        if (parsed) {
+                            const fingerprint = JSON.stringify(parsed);
+                            if (lastJobFingerprint.get(parsed.jobId) === fingerprint)
+                                continue;
+                            lastJobFingerprint.set(parsed.jobId, fingerprint);
+                            const pollCount = (jobPollCount.get(parsed.jobId) ?? 0) + 1;
+                            jobPollCount.set(parsed.jobId, pollCount);
+                            out.push({
+                                stream: "tool_result",
+                                text: `⏺ Background job ${parsed.jobId} · ${parsed.state}`,
+                                payload: { ...parsed, kind: "background_job", pollCount },
+                            });
+                            continue;
+                        }
+                        // 解析不出来就走下面的通用分支,降级成纯文本行,不猜。
+                    }
                     if (!block.is_error && tool?.name === "Read" && typeof tool.input?.file_path === "string") {
                         const start = typeof tool.input.offset === "number" && Number.isSafeInteger(tool.input.offset)
                             ? Math.max(1, tool.input.offset) : 1;
@@ -71,7 +146,7 @@ export function createConsoleFormatter() {
                 }
                 return out;
             }
-            return toConsoleLines(event);
+            return dedupeTodos(toConsoleLines(event));
         },
     };
 }

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/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,16 +506,64 @@ 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);
         }
         let recalledMemory = "";
@@ -788,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

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

@@ -5,6 +5,21 @@
  * 只有本机事实(CREW_HOME / work-log / MEMORY 注入)是可选增强,按整段丢弃或按字节截断。
  */
 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,11 +46,11 @@ 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 }) => {
+    return ({ workspace, resuming, projectContext, trainingProjectContext }) => {
         const memory = capMemoryForInject(workspace.memory);
         const workLog = resuming ? "" : capWorkLogForInject(workspace.workLog);
         const collaborationPrompt = options.collaborationTools === true ? buildCollaborationToolsPrompt() : "";
-        const mandatoryWorkspacePrompt = buildRuntimeWorkspacePrompt(projectContext);
+        const mandatoryWorkspacePrompt = `${buildRuntimeWorkspacePrompt(projectContext)}${buildTrainingGitProjectPrompt(trainingProjectContext)}`;
         const localFactSections = [`\n\n## Local execution facts
 - $CREW_HOME: ${workspace.dir}
 - $CREW_TASK_LOG: ${workspace.workLogPath}`,

package/dist/local-executor.js

@@ -374,6 +374,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             rotatedForBudget,
             nearBudget,
             ...(input.projectContext === undefined ? {} : { projectContext: input.projectContext }),
+            ...(input.trainingProjectContext === undefined ? {} : { trainingProjectContext: input.trainingProjectContext }),
         };
         if (input.attachments && input.attachments.length > 0) {
             if (dependencies.cancellation?.isRequested())
@@ -590,19 +591,23 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                     skill_count: abilityContext.skillCount,
                 });
             }
+            const trainingRoots = input.trainingProjectContext?.projects.map((project) => project.root) ?? [];
             const { codexSkillRoots, claudeAdditionalDirectories } = await projectSkillRuntimeDirectories({
                 runtime: runtime.name,
                 ...(runtimeRoot === undefined ? {} : { runtimeRoot }),
                 agentRoot: workspace.dir,
                 projectSkillsPresent: input.projectSkills !== undefined,
                 ...(input.projectContext === undefined ? {} : { projectContext: input.projectContext }),
+                ...(input.trainingProjectContext === undefined ? {} : {
+                    trainingProjectRoots: input.trainingProjectContext.projects.map((project) => project.root),
+                }),
                 ...(abilityContext?.skillRoot === undefined
                     ? {}
                     : { abilitySkillRoot: abilityContext.skillRoot }),
             });
             let runtimeEnv = childEnv;
             if (runtime.name === "claude"
-                && input.projectContext !== undefined
+                && (input.projectContext !== undefined || trainingRoots.length > 0)
                 && claudeAdditionalDirectories.length > 0) {
                 const version = await (dependencies.probeClaudeVersion ?? probeClaudeVersion)(runtime.name, childEnv)
                     .catch(() => null);
@@ -621,6 +626,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                     });
                 }
             }
+            const legacyRoots = input.projectContext?.secondary.map((project) => project.root) ?? [];
+            const workspaceRoots = [...legacyRoots, ...trainingRoots];
             const launchRequest = {
                 runtime: runtime.name,
                 bin: runtime.name === "deepseek-harness" ? "dsh-acp-demo" : runtime.name,
@@ -651,9 +658,14 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                     ? {}
                     : { claudeAdditionalDirectories }),
                 ...(input.projectContext === undefined ? {} : {
-                    workspaceRoots: Object.freeze(input.projectContext.secondary.map((project) => project.root)),
                     projectContext: input.projectContext,
                 }),
+                ...(input.projectContext === undefined && workspaceRoots.length === 0
+                    ? {}
+                    : { workspaceRoots: Object.freeze(workspaceRoots) }),
+                ...(input.trainingProjectContext === undefined ? {} : {
+                    trainingProjectContext: input.trainingProjectContext,
+                }),
             };
             return launchRequest;
         };