@nowcrew/daemon 0.6.88-beta.2 → 0.6.88-beta.21

package/dist/local-memory/work-log-execution.js

@@ -0,0 +1,31 @@
+import { resolve } from "node:path";
+import { withKeyedLease } from "../local-execution-lease.js";
+// 只记录尚未结束的本机执行，最后一个执行结束即移除，不落盘。
+const activeExecutions = new Map();
+export function workLogExecutionKey(agentsRoot, handle, taskKey) {
+    return `work-log:${JSON.stringify([resolve(agentsRoot, handle), taskKey ?? "default"])}`;
+}
+export async function withWorkLogExecution(key, operation, cancellation) {
+    // 只在登记期间持锁；普通任务与收尾的模型调用仍可并行。
+    await withKeyedLease(key, async () => {
+        activeExecutions.set(key, (activeExecutions.get(key) ?? 0) + 1);
+    }, cancellation);
+    try {
+        return await operation();
+    }
+    finally {
+        const remaining = (activeExecutions.get(key) ?? 1) - 1;
+        if (remaining === 0)
+            activeExecutions.delete(key);
+        else
+            activeExecutions.set(key, remaining);
+    }
+}
+export async function withWorkLogCommit(key, operation, cancellation) {
+    return withKeyedLease(key, async () => {
+        // 已有同任务执行可能继续写日志，不能提交旧提案；新执行等短提交结束后再登记。
+        if (activeExecutions.get(key) !== 1)
+            throw new Error("local_memory_work_log_execution_conflict");
+        return operation();
+    }, cancellation);
+}

package/dist/local-memory/work-log.js

@@ -0,0 +1,58 @@
+import { lstat, readFile, realpath } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { safeKey } from "../workspace.js";
+/** 收尾会话可以换目录，但仍应消费同一任务已写好的日志；不迁移文件或复用会话。 */
+export async function resolveMemoryPruneWorkLog(workspace, input) {
+    // 旧映射有损时无法证明是同一任务，不能用它查找或清理来源。
+    if (input.keyMode !== "opaque" || !input.taskKey || safeKey(input.taskKey) !== input.taskKey) {
+        return workspace;
+    }
+    const legacyPath = join(workspace.dir, "tasks", input.taskKey, "work-log.md");
+    if (legacyPath === workspace.workLogPath)
+        return workspace;
+    let legacyStat;
+    try {
+        legacyStat = await lstat(legacyPath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return workspace;
+        throw error;
+    }
+    if (!legacyStat.isFile() || legacyStat.isSymbolicLink()
+        || await realpath(legacyPath) !== join(await realpath(workspace.dir), "tasks", input.taskKey, "work-log.md")) {
+        throw new Error("local_memory_work_log_path_invalid");
+    }
+    const workLog = await readFile(legacyPath, "utf8");
+    if (workLog.length === 0)
+        return workspace;
+    if ((await readFile(workspace.workLogPath, "utf8")).length > 0) {
+        throw new Error("local_memory_work_log_source_conflict");
+    }
+    return { ...workspace, workLogPath: legacyPath, workLog };
+}
+export function workLogSha256(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+/** 调用方须在同任务的提交互斥边界内校验；指纹对应实际注入模型的那一版内容。 */
+export async function verifyWorkLogSource(agentDir, path, expectedSha256) {
+    if (expectedSha256 === undefined)
+        throw new Error("local_memory_work_log_version_missing");
+    const relativePath = relative(resolve(agentDir), resolve(path));
+    if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+        throw new Error("local_memory_work_log_path_invalid");
+    }
+    const before = await lstat(path);
+    if (!before.isFile() || before.isSymbolicLink()
+        || await realpath(path) !== join(await realpath(agentDir), relativePath)) {
+        throw new Error("local_memory_work_log_path_invalid");
+    }
+    const content = await readFile(path);
+    const after = await lstat(path);
+    if (workLogSha256(content) !== expectedSha256 || before.dev !== after.dev || before.ino !== after.ino
+        || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs) {
+        throw new Error("local_memory_work_log_source_changed");
+    }
+    return after;
+}

package/dist/local-memory/write.js

@@ -2,29 +2,12 @@ import { createHash, randomUUID } from "node:crypto";
 import { lstat, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { z } from "zod";
-import { containsLikelySecret } from "../agent-memory/policy.js";
-import { LOCAL_MEMORY_INDEX_CODE_POINT_CAP, LOCAL_MEMORY_INDEX_ENTRY_CAP, LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, renderLocalMemoryIndexCard, selectLocalMemoryIndexEntries, } from "./index-budget.js";
+import { dslog } from "../slog.js";
+import { LocalMemoryChangeSchema, LocalMemorySingleLineText, validateLocalMemoryChange, } from "./candidate.js";
+import { LOCAL_MEMORY_INDEX_CODE_POINT_CAP, LOCAL_MEMORY_INDEX_ENTRY_CAP, LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, renderGeneratedIndex, selectLocalMemoryIndexEntries, } from "./index-budget.js";
 import { persistPendingMemoryCandidate, readPendingMemoryCandidates, removePendingMemoryCandidate, } from "./pending.js";
-const CategorySchema = z.enum([
-    "preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons",
-]);
-const SingleLineText = z.string().trim().min(1).max(500).regex(/^[^\r\n]+$/u);
-const ChangeSchema = z.object({
-    operation: z.enum(["create", "update", "supersede"]),
-    memoryId: SingleLineText.regex(/^[^<>]+$/u).nullable(),
-    baseRevision: z.number().int().nonnegative().nullable(),
-    supersedesMemoryId: SingleLineText.regex(/^[^<>]+$/u).nullable(),
-    title: SingleLineText.max(120),
-    kind: z.enum(["procedural", "semantic", "episodic", "preference"]),
-    summary: SingleLineText,
-    triggers: z.array(SingleLineText.max(80)).min(1).max(16),
-    priority: z.enum(["high", "medium", "low"]),
-    detailCategory: CategorySchema,
-    detailBody: z.string().trim().min(1).max(12_000),
-    reviewAfter: SingleLineText.nullable(),
-}).strict();
 const StatusChangeSchema = z.object({
-    memoryId: SingleLineText,
+    memoryId: LocalMemorySingleLineText,
     expectedRevision: z.number().int().positive(),
     expectedStatus: z.enum(["candidate", "active", "pinned", "stale", "superseded", "archived"]),
     targetStatus: z.enum(["candidate", "active", "pinned", "stale", "archived"]),
@@ -35,7 +18,7 @@ const ResultSchema = z.object({
     purpose: z.literal("memory_prune"),
     baseCatalogRevision: z.number().int().nonnegative(),
     outcome: z.enum(["no_change", "proposed", "conflict", "failed"]),
-    changes: z.array(ChangeSchema).max(50),
+    changes: z.array(LocalMemoryChangeSchema).max(50),
     statusChanges: z.array(StatusChangeSchema).max(50),
 }).strict();
 const GENERATED_INDEX_PATTERN = /<!--\s*NOWWORK:MEMORY_INDEX:BEGIN\s+schema=1\s*-->[\s\S]*?<!--\s*NOWWORK:MEMORY_INDEX:END\s*-->/u;
@@ -43,8 +26,6 @@ const INDEX_HEADING = /^##\s+Knowledge Index\s*$/mu;
 const NEXT_SECTION = /^##\s+(?!#)/mu;
 const CARD_HEADING = /^###\s+(.+?)\s*$/gmu;
 const FIELD_LINE = /^-\s+([a-z][a-z_]*)\s*:\s*(.*?)\s*$/iu;
-const CONTROL_CHARACTER_PATTERN = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u;
-const RESERVED_MEMORY_MARKER = /NOWWORK:(?:MEMORY_ENTRY|MEMORY_INDEX):/iu;
 function codePointLength(value) {
     return Array.from(value).length;
 }
@@ -117,13 +98,6 @@ function parseUnmarkedMemoryIndex(memory) {
     const section = indexSection(memory).replace(GENERATED_INDEX_PATTERN, "");
     return parseCards(section);
 }
-function renderGeneratedIndex(entries) {
-    const cards = entries
-        .filter((entry) => entry.status === "pinned" || entry.status === "active")
-        .map(renderLocalMemoryIndexCard)
-        .join("\n");
-    return `<!-- NOWWORK:MEMORY_INDEX:BEGIN schema=1 -->\n${cards}<!-- NOWWORK:MEMORY_INDEX:END -->`;
-}
 function replaceGeneratedIndex(memory, entries) {
     const generated = renderGeneratedIndex(entries);
     if (GENERATED_INDEX_PATTERN.test(memory))
@@ -135,9 +109,15 @@ function replaceGeneratedIndex(memory, entries) {
     }
     return `${memory.trimEnd()}\n\n## Knowledge Index\n${generated}\n`;
 }
+function unwrappedNoteBody(title, body) {
+    const detail = body.trim();
+    const heading = /^([^\r\n]+)\r?\n\r?\n/u.exec(detail);
+    // Agent 可能回传包含包装标题的全文；只解开一层，保留内部及历史标题。
+    return heading?.[1] === `## ${title}` ? detail.slice(heading[0].length) : detail;
+}
 function noteSection(id, revision, title, body) {
     return `<!-- NOWWORK:MEMORY_ENTRY:BEGIN id=${id} revision=${revision} -->\n`
-        + `## ${title}\n\n${body.trim()}\n`
+        + `## ${title}\n\n${unwrappedNoteBody(title, body)}\n`
         + `<!-- NOWWORK:MEMORY_ENTRY:END id=${id} -->\n`;
 }
 function notePattern(id) {
@@ -148,34 +128,12 @@ function replaceNote(content, id, replacement) {
     const pattern = notePattern(id);
     return pattern.test(content) ? content.replace(pattern, replacement) : null;
 }
-function containsReservedText(change) {
-    return RESERVED_MEMORY_MARKER.test([change.title, change.summary, ...change.triggers, change.detailBody].join("\n"));
-}
 function validateCandidate(result) {
     if (result.outcome === "no_change" && (result.changes.length > 0 || result.statusChanges.length > 0)) {
         throw new Error("local_memory_no_change_has_operations");
     }
-    for (const change of result.changes) {
-        const text = [change.title, change.summary, ...change.triggers, change.detailBody].join("\n");
-        if (containsLikelySecret(text))
-            throw new Error("local_memory_secret_candidate");
-        if (CONTROL_CHARACTER_PATTERN.test(text))
-            throw new Error("local_memory_control_character");
-        if (containsReservedText(change))
-            throw new Error("local_memory_reserved_marker");
-        if (change.operation === "create"
-            && (change.memoryId !== null || change.baseRevision !== null || change.supersedesMemoryId !== null)) {
-            throw new Error("local_memory_create_revision_invalid");
-        }
-        if (change.operation === "update"
-            && (change.memoryId === null || change.baseRevision === null || change.supersedesMemoryId !== null)) {
-            throw new Error("local_memory_update_revision_missing");
-        }
-        if (change.operation === "supersede"
-            && (change.memoryId !== null || change.baseRevision === null || change.supersedesMemoryId === null)) {
-            throw new Error("local_memory_supersede_revision_missing");
-        }
-    }
+    for (const change of result.changes)
+        validateLocalMemoryChange(change);
 }
 export function parseLocalMemoryResult(raw) {
     let value;
@@ -477,7 +435,16 @@ export async function applyLocalMemoryResult(input) {
         // Pending create candidates are durable overflow, not dead ends. Promote only
         // when the current catalog has room; supersede/update candidates stay pending
         // until a fresh revision-aware decision can safely replay them.
-        const pendingCandidatesOnDisk = await readPendingMemoryCandidates({ agentDir: input.agentDir });
+        const pendingCandidatesOnDisk = await readPendingMemoryCandidates({ agentDir: input.agentDir }).catch((error) => {
+            if (!(error instanceof Error) || error.message !== "memory_pending_directory_over_budget")
+                throw error;
+            // 自动提升是可选工作，目录查询预算不应阻断本轮已验证的更新或腾位操作。
+            dslog("local_memory.pending_promotion_skipped", "pending目录超出扫描预算，本轮跳过自动提升", {
+                level: "WARN", execution_id: input.executionId, prune_trace_id: input.pruneTraceId,
+                reason: "memory_pending_directory_over_budget",
+            });
+            return [];
+        });
         for (const pending of pendingCandidatesOnDisk) {
             const change = pending.candidate;
             if (change.operation !== "create")
@@ -494,8 +461,10 @@ export async function applyLocalMemoryResult(input) {
             if (duplicate !== undefined) {
                 const duplicatePath = resolve(input.agentDir, duplicate.file);
                 const duplicateBody = readNoteBody(noteUpdates.get(duplicatePath) ?? await readNote(duplicatePath), duplicate.id);
-                if (duplicateBody === change.detailBody)
+                if (duplicateBody === change.detailBody
+                    || duplicateBody === unwrappedNoteBody(change.title, change.detailBody).trim()) {
                     resolvedPendingIds.add(pending.pendingId);
+                }
                 continue;
             }
             const entry = entryFromChange(change, id, 1, "active");

package/dist/machine-info.js

@@ -1,7 +1,10 @@
+import { retryHarnessProbe } from "./runtimes/harness-probe-retry.js";
 /**
  * 采集本机信息上报给控制面 (machine:hello):hostname / os / daemon 版本 / 已装 runtimes。
  * runtimes 探测靠 `which <bin>`(win32 用 `where`),只报真实可执行的 CLI(用于展示 Detected Runtimes)。
  */
+import { randomUUID } from "node:crypto";
+import { dslog } from "./slog.js";
 import { hostname, arch, platform as osPlatform } from "node:os";
 import { lookupCmd } from "./platform.js";
 import { augmentedPath } from "./runtime-path.js";
@@ -14,11 +17,11 @@ import { createRequire } from "node:module";
 import { dirname, resolve } from "node:path";
 import { executableRuntimes } from "./runtime-capabilities.js";
 import { executionBackendCapability } from "./execution-backend.js";
-import { probeKimiAcp } from "./runtimes/kimi-acp-runner.js";
+import { probeKimiAcp, AcpProbeCleanupError } from "./runtimes/kimi-acp-runner.js";
 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 { probeDeepSeekHarnessAcp, deepSeekHarnessLauncher } from "./runtimes/deepseek-harness.js";
 import { daemonHome } from "./computer-profile.js";
 import { daemonReleaseProvenance } from "./release-provenance.js";
 export { executableRuntimes } from "./runtime-capabilities.js";
@@ -90,7 +93,7 @@ const RUNTIME_BINS = [
     ["gemini", "gemini"],
     ["hermes", "hermes"],
     ["opencode", "opencode"],
-    ["deepseek-harness", "dsh-acp-demo"],
+    ["deepseek-harness", "dsh"],
     ["copilot", "copilot"],
     ["kimi", "kimi"],
     ["pi", "pi"],
@@ -107,29 +110,64 @@ async function isInstalled(bin) {
 }
 /** 并发探测所有候选 runtime,返回已安装的展示名列表。 */
 export async function detectRuntimes() {
-    const checks = await Promise.all(RUNTIME_BINS.map(async ([name, bin]) => ((await isInstalled(bin)) ? name : null)));
+    const checks = await Promise.all(RUNTIME_BINS.map(async ([name, bin]) => {
+        try {
+            return await isInstalled(name === "deepseek-harness" ? deepSeekHarnessLauncher().bin : bin) ? name : null;
+        }
+        catch {
+            return null;
+        }
+    }));
     return checks.filter((x) => x !== null);
 }
-async function supportsKimiAcp(signal) {
-    return probeKimiAcp({ bin: "kimi", ...(signal ? { signal } : {}) });
+async function supportsKimiAcp(signal, probeId) {
+    return probeKimiAcp({ bin: "kimi", ...(probeId ? { probeId } : {}), ...(signal ? { signal } : {}) });
 }
-async function supportsHermesAcp(signal) {
-    return probeHermesAcp({ bin: "hermes", ...(signal ? { signal } : {}) });
+async function supportsHermesAcp(signal, probeId) {
+    return probeHermesAcp({ bin: "hermes", ...(probeId ? { probeId } : {}), ...(signal ? { signal } : {}) });
 }
 async function supportsOpenCodeRun(signal) {
     return probeOpenCodeRun(signal);
 }
-async function supportsDeepSeekHarnessAcp(signal) {
-    return probeDeepSeekHarnessAcp({ bin: "dsh-acp-demo", ...(signal ? { signal } : {}) });
+async function supportsDeepSeekHarnessAcp(signal, probeId) {
+    try {
+        return await probeDeepSeekHarnessAcp({ bin: deepSeekHarnessLauncher().bin, ...(probeId ? { probeId } : {}), ...(signal ? { signal } : {}) });
+    }
+    catch (error) {
+        if (error instanceof AcpProbeCleanupError)
+            throw error;
+        return false;
+    }
 }
 /** Runtime adapters that can satisfy the durable protocol-v1 process contract. */
-export async function detectExecutionRuntimes(installed = detectRuntimes(), kimiAcpProbe = supportsKimiAcp, hermesAcpProbe = supportsHermesAcp, openCodeProbe = supportsOpenCodeRun, deepSeekHarnessProbe = supportsDeepSeekHarnessAcp, signal) {
+export async function detectExecutionRuntimes(installed = detectRuntimes(), kimiAcpProbe = supportsKimiAcp, hermesAcpProbe = supportsHermesAcp, openCodeProbe = supportsOpenCodeRun, deepSeekHarnessProbe = supportsDeepSeekHarnessAcp, signal, probeId = randomUUID()) {
     const present = await installed;
+    const probe = (runtime, detect) => {
+        const startedAt = Date.now();
+        dslog("runtime_probe.optional_start", "开始可选 runtime 探测", { probe_id: probeId, runtime, aborted: signal?.aborted ?? false });
+        const complete = (outcome, ready) => {
+            dslog("runtime_probe.optional_complete", "可选 runtime 探测结束", {
+                probe_id: probeId, runtime, outcome, duration_ms: Date.now() - startedAt,
+                aborted: signal?.aborted ?? false, ...(ready === undefined ? {} : { ready }),
+            });
+        };
+        let pending;
+        try {
+            pending = detect(signal, probeId);
+        }
+        catch (error) {
+            complete("threw");
+            throw error;
+        }
+        return pending.then((ready) => { complete("resolved", ready); return ready; }, (error) => { complete("threw"); throw error; });
+    };
     const [kimiReady, hermesReady, openCodeReady, deepSeekHarnessReady] = await Promise.all([
-        present.includes("kimi") ? kimiAcpProbe(signal) : false,
-        present.includes("hermes") ? hermesAcpProbe(signal) : false,
-        present.includes("opencode") ? openCodeProbe(signal) : false,
-        present.includes("deepseek-harness") ? deepSeekHarnessProbe(signal) : false,
+        present.includes("kimi") ? probe("kimi", kimiAcpProbe) : false,
+        present.includes("hermes") ? probe("hermes", hermesAcpProbe) : false,
+        present.includes("opencode") ? probe("opencode", openCodeProbe) : false,
+        present.includes("deepseek-harness")
+            ? retryHarnessProbe(() => probe("deepseek-harness", deepSeekHarnessProbe), signal, probeId)
+            : false,
     ]);
     return executableRuntimes(present).filter((runtime) => (runtime === "kimi" ? kimiReady
         : runtime === "hermes" ? hermesReady
@@ -137,7 +175,7 @@ export async function detectExecutionRuntimes(installed = detectRuntimes(), kimi
                 : runtime === "deepseek-harness" ? deepSeekHarnessReady
                     : true));
 }
-export const detectExecutionRuntimesWithSignal = (installed, signal) => detectExecutionRuntimes(installed, supportsKimiAcp, supportsHermesAcp, supportsOpenCodeRun, supportsDeepSeekHarnessAcp, signal);
+export const detectExecutionRuntimesWithSignal = (installed, signal, probeId) => detectExecutionRuntimes(installed, supportsKimiAcp, supportsHermesAcp, supportsOpenCodeRun, supportsDeepSeekHarnessAcp, signal, probeId);
 export function daemonVersion() {
     try {
         const here = dirname(fileURLToPath(import.meta.url));
@@ -203,7 +241,6 @@ export async function collectMachineHello(agentsRoot, executionLimits, runtimePl
         runtimes,
         executionRuntimes,
         capabilities,
-        ...(dependencies.codexHomeMode === undefined ? {} : { codexHomeMode: dependencies.codexHomeMode }),
         ...(dependencies.profileName === undefined ? {} : {
             layoutVersion: 1,
             profileName: dependencies.profileName,

package/dist/main.js

@@ -7,7 +7,6 @@
  */
 import { parseArgs } from "node:util";
 import { homedir } from "node:os";
-import { join } from "node:path";
 import { loadConfig, ConfigError } from "./config.js";
 import { detectDaemonLang, formatDaemonText, translateDaemon } from "./i18n.js";
 import { cliVersion, daemonVersion } from "./machine-info.js";
@@ -25,19 +24,9 @@ import { assertManagedServiceStartup } from "./managed-service-startup.js";
 import { daemonGlobalInstallation } from "./daemon-installation.js";
 import { acquireDaemonInstallationLease, runWithDaemonInstallationLease, } from "./daemon-installation-lease.js";
 import { createStorageRuntimeOwnershipBinding, loadStorageRuntime } from "./storage-runtime.js";
-import { readStorageMigrationReceipt } from "./storage-migration-controller.js";
-import { storageMigrationStatusReplay } from "./storage-status-replay.js";
-import { runStorageWorkerCommand } from "./storage-worker-command.js";
-import { probeStorageMigrationRuntime } from "./storage-runtime-readiness.js";
-import { createStorageTargetConfirmationHandler } from "./storage-target-confirmation.js";
 import { resolveDaemonLocalStateRoot } from "./daemon-local-home.js";
 import { storageServiceEnvironment } from "./computer-service.js";
 async function main() {
-    const workerResult = await runStorageWorkerCommand(process.argv.slice(2));
-    if (workerResult !== null) {
-        process.exitCode = workerResult;
-        return;
-    }
     const computerResult = await runComputerCommand(process.argv.slice(2));
     if (computerResult !== null) {
         process.exitCode = computerResult;
@@ -74,7 +63,6 @@ async function main() {
     // 不把 machine token 放进 argv / plist / systemd unit / scheduled task。
     if (values["daemon-home"])
         process.env.CREW_DAEMON_HOME = values["daemon-home"];
-    let activeDaemonHome;
     const localHome = resolveDaemonLocalStateRoot({
         userHome: homedir(),
         platform: process.platform,
@@ -85,7 +73,6 @@ async function main() {
     });
     if (values.profile) {
         const home = daemonHome(process.env, values.profile);
-        activeDaemonHome = home;
         const profile = await loadProfile(values.profile, home);
         if (cmd === "serve") {
             await assertProfileAgentsRootUnique(profile, home, homedir());
@@ -148,68 +135,16 @@ async function main() {
         const installationLease = installation === null
             ? null
             : await acquireDaemonInstallationLease(installation.npmPrefix, { localHome });
-        const migrationRuntime = values.profile === undefined || activeDaemonHome === undefined || storageRuntime !== null
-            ? { ready: false, reason: "not_legacy_source" }
-            : await probeStorageMigrationRuntime({
-                profile: values.profile,
-                serverUrl: config.serverUrl,
-                currentDaemonHome: activeDaemonHome,
-                currentAgentsRoot: config.agentsRoot,
-                userHome: homedir(),
-                platform: process.platform,
-                ...(process.getuid === undefined ? {} : { uid: process.getuid() }),
-                environment: process.env,
-            });
-        const targetStorageBinding = storageRuntime === null
+        const storageBinding = storageRuntime === null
             ? null
             : createStorageRuntimeOwnershipBinding(storageRuntime);
-        const targetConfirmation = storageRuntime?.identity.storageMigrationId === undefined
-            ? null
-            : createStorageTargetConfirmationHandler({
-                backupsRoot: storageRuntime.local.backupsRoot,
-                identity: storageRuntime.identity,
-                profile: storageRuntime.installation.profile,
-                completionTimeoutMs: 180_000,
-            });
-        const storageMigration = storageRuntime !== null
-            ? {
-                ready: false,
-                statusOutboxPath: join(storageRuntime.local.stateRoot, "storage-status-outbox.json"),
-                identity: targetStorageBinding.identity,
-                bindServerIdentity: targetStorageBinding.bind,
-                ...(targetConfirmation === null ? {} : { confirm: targetConfirmation.handle }),
-                ...(storageRuntime.identity.storageMigrationId === undefined ? {} : {
-                    replayStatus: async (send) => {
-                        const migrationId = storageRuntime.identity.storageMigrationId;
-                        const receipt = await readStorageMigrationReceipt(storageRuntime.local.backupsRoot, migrationId);
-                        if (receipt === null)
-                            throw new Error(`storage migration receipt not found: ${migrationId}`);
-                        for (const frame of storageMigrationStatusReplay(receipt, {
-                            migrationId,
-                            environment: storageRuntime.identity.storageEnvironment,
-                            workspaceId: storageRuntime.identity.storageWorkspaceId,
-                            profile: storageRuntime.installation.profile,
-                        }))
-                            send(frame);
-                    },
-                }),
-            }
-            : migrationRuntime.ready
-                ? {
-                    ready: true,
-                    statusOutboxPath: migrationRuntime.runtime.statusOutboxPath,
-                    identity: migrationRuntime.runtime.identity,
-                    controller: migrationRuntime.runtime.controller,
-                    attach: migrationRuntime.runtime.attach,
-                    bindServerIdentity: migrationRuntime.runtime.bindServerIdentity,
-                    replayStatus: migrationRuntime.runtime.replayStatus,
-                }
-                : undefined;
         await runWithDaemonInstallationLease(installationLease, async () => {
             const service = serve(runtimeConfig, {
                 ...(values.profile === undefined ? {} : { profileName: values.profile }),
                 localHome,
-                ...(storageMigration === undefined ? {} : { storageMigration }),
+                ...(storageBinding === null ? {} : {
+                    storageRuntime: { identity: storageBinding.identity, bindServerIdentity: storageBinding.bind },
+                }),
             });
             await runServeLifecycle(service);
         });

package/dist/native-thread-context.js

@@ -0,0 +1,59 @@
+import { readFile, writeFile, rm } from "node:fs/promises";
+export function isolateMaintenanceSession(input) {
+    if (input.maintenancePurpose === undefined)
+        return input;
+    const { resumeKey: _ignored, ...rest } = input;
+    return { ...rest, session: { ...input.session, enabled: false } };
+}
+/** A per-execution runtime handoff, not a transcript or daemon business store. */
+export class NativeThreadContext {
+    path;
+    threadRoot;
+    runtime;
+    requestedSessionId;
+    prior;
+    confirmed = false;
+    constructor(path, threadRoot, runtime, requestedSessionId, prior) {
+        this.path = path;
+        this.threadRoot = threadRoot;
+        this.runtime = runtime;
+        this.requestedSessionId = requestedSessionId;
+        this.prior = prior;
+    }
+    snapshot() {
+        const reusable = this.requestedSessionId !== null && this.prior?.sessionId === this.requestedSessionId
+            && this.prior?.threadRoot === this.threadRoot && this.prior?.runtime === this.runtime;
+        return { schemaVersion: 1, threadRoot: this.threadRoot, resumeConfirmed: this.confirmed,
+            historyComplete: false, readSeq: 0,
+            resumeCandidate: reusable ? { sessionId: this.requestedSessionId,
+                historyComplete: this.prior?.threadHistoryComplete === true, readSeq: this.prior?.threadContextSeq ?? 0 } : null };
+    }
+    async initialize() { await writeFile(this.path, JSON.stringify(this.snapshot()), { mode: 0o600 }); }
+    observe(raw) {
+        if (this.confirmed || !this.requestedSessionId || !raw || typeof raw !== "object")
+            return;
+        const event = raw;
+        const confirmed = (this.runtime === "claude" || this.runtime === "codex")
+            && event.type === "nowwork.native_resume" && event.session_id === this.requestedSessionId
+            && (event.runtime === undefined || event.runtime === this.runtime);
+        if (!confirmed)
+            return;
+        this.confirmed = true;
+        // Telemetry only. The native adapter verifies its handshake directly and
+        // commits accepted input itself. Writing here could race that commit and
+        // reset the delivered cursor when parent stdout consumption is delayed.
+    }
+    async checkpoint() {
+        try {
+            const state = JSON.parse(await readFile(this.path, "utf8"));
+            if (state.schemaVersion !== 1 || state.threadRoot !== this.threadRoot
+                || !Number.isSafeInteger(state.readSeq) || state.readSeq < 0)
+                return null;
+            return { threadContextSeq: state.readSeq, threadHistoryComplete: state.historyComplete === true };
+        }
+        catch {
+            return null;
+        }
+    }
+    async cleanup() { await rm(this.path, { force: true }); }
+}

package/dist/pre-admission-rejection.js

@@ -0,0 +1,64 @@
+import { ExecutionCompletedSchema, ExecutionRejectedSchema } from "./execution-protocol.js";
+import { hashExecutionSpec } from "./execution-runner.js";
+import { dslog } from "./slog.js";
+/** Queue rejection is admission work too: own the ID before any asynchronous journal write. */
+export async function rejectQueuedAdmission(context, spec, executionClass, facts) {
+    const id = spec.executionId;
+    const hash = hashExecutionSpec(spec);
+    if (context.knownExecutionHashes.has(id) || context.executionRuns.has(id)) {
+        // A same-ID request won while the caller awaited journal.get. Its journal may
+        // still be pending; silence lets its real result arrive instead of rejecting it.
+        const existing = await context.journal.get(id);
+        if (existing?.specHash === hash)
+            context.replay(existing);
+        return;
+    }
+    context.knownExecutionHashes.set(id, hash);
+    const rejected = ExecutionRejectedSchema.parse({
+        type: "execution:rejected", protocolVersion: 1, executionId: id,
+        reason: "resource_limit", message: "Local machine execution queue is full", at: new Date().toISOString(),
+    });
+    dslog("execution.machine_queue_rejected", "机器执行队列已满", {
+        level: "WARN", execution_id: id, agent_handle: spec.agent.handle, execution_class: executionClass, ...facts,
+    });
+    const rejecting = persistPreAdmissionRejection(context.journal, spec, rejected)
+        .then(async (entry) => {
+        if (entry)
+            await context.report({ ...rejected, preAdmissionProof: { specHash: hash } });
+        else {
+            const existing = await context.journal.get(id);
+            if (existing?.specHash === hash)
+                context.replay(existing);
+        }
+    })
+        .catch(error => {
+        // A failed durable write has no safe rejection proof; a restart/sync will
+        // reconcile an accepted tombstone if this admission created one.
+        dslog("execution.admission_rejection_failed", "准入拒绝未取得持久停止证明", {
+            level: "ERROR", execution_id: id, error_message: String(error),
+        });
+    })
+        .finally(() => {
+        if (context.executionRuns.get(id) === rejecting) {
+            context.executionRuns.delete(id);
+            context.knownExecutionHashes.delete(id);
+        }
+    });
+    context.executionRuns.set(id, rejecting);
+    await rejecting;
+}
+/** The caller synchronously owns this admission ID. Never complete somebody else's record. */
+export async function persistPreAdmissionRejection(journal, spec, rejection) {
+    const accepted = await journal.accept(spec.executionId, hashExecutionSpec(spec), {
+        runtime: spec.runtime.name, ...(spec.runtime.model ? { model: spec.runtime.model } : {}), resumed: false,
+    });
+    if (accepted.kind !== "created")
+        return null;
+    return journal.complete(spec.executionId, ExecutionCompletedSchema.parse({
+        type: "execution:completed", protocolVersion: 1, executionId: spec.executionId,
+        outcome: "failed", errorCode: rejection.reason, errorMessage: rejection.message ?? "Admission rejected before runtime start",
+        runtime: spec.runtime.name, ...(spec.runtime.model ? { model: spec.runtime.model } : {}), resumed: false,
+        startedAt: accepted.acceptedAt,
+        finishedAt: new Date(Math.max(Date.now(), Date.parse(accepted.acceptedAt))).toISOString(),
+    }));
+}

package/dist/project-skills/execution-adapter.js

@@ -9,10 +9,11 @@ export function projectSkillExecutionProjection(bindings, generation) {
         });
 }
 /**
- * 投影门控与 ownership 判定的唯一谓词:只有绑定了 Project Skills 且运行时是 codex/claude 的执行
+ * 投影门控与 ownership 判定的唯一谓词:只有绑定了 Project Skills 且运行时支持受控目录的执行
  * 才会有投影目录,也才需要在停止无法证明时保留它。两处判定分开写过一次,结果 kimi + projectSkills
  * 会在取消路径上错抛 ownership 未确认。
  */
 export const projectSkillProjectionApplies = (spec) => spec.agent.projectSkills !== undefined
-    && (spec.runtime.name === "codex" || spec.runtime.name === "claude");
+    && (spec.runtime.name === "codex" || spec.runtime.name === "claude"
+        || spec.runtime.name === "deepseek-harness");
 export const projectSkillProjectionErrorCode = (error) => error instanceof ProjectProjectionError ? error.code : null;

package/dist/project-skills/runtime-launch.js

@@ -11,12 +11,26 @@ export function projectSkillRuntimeLaunchFacts(runtime, root) {
     if (runtime === "claude") {
         return Object.freeze({ claudeAdditionalDirectory: root.claudeAdditionalDirectory });
     }
+    if (runtime === "deepseek-harness") {
+        return Object.freeze({ harnessSkillRoot: root.codexSkillRoot });
+    }
     throw new ProjectProjectionError("skill_projection_failed");
 }
 /** Builds Runtime-native arrays while keeping v1 shared roots separate from v2 exact roots. */
 export async function projectSkillRuntimeDirectories(input) {
     const trainingProjectRoots = input.trainingProjectRoots ?? [];
     const facts = projectSkillRuntimeLaunchFacts(input.runtime, input.runtimeRoot);
+    if (input.runtime === "deepseek-harness") {
+        // Harness 的 local provider 接受直接包含 Skill 子目录的受控 root,不扫描项目/用户目录。
+        return Object.freeze({
+            codexSkillRoots: Object.freeze([]),
+            claudeAdditionalDirectories: Object.freeze([]),
+            harnessSkillRoots: Object.freeze([
+                ...(facts.harnessSkillRoot === undefined ? [] : [facts.harnessSkillRoot]),
+                ...(input.abilitySkillRoot === undefined ? [] : [input.abilitySkillRoot]),
+            ]),
+        });
+    }
     const codexSkillRoots = input.runtime === "codex"
         && (input.runtimeRoot !== undefined || input.projectContext !== undefined)
         ? Object.freeze([