@nowcrew/daemon 0.6.77 → 0.6.78

package/dist/project-skills/resolution-records.js

@@ -0,0 +1,63 @@
+import { posix, win32 } from "node:path";
+import { compareProjectSkillRefs, isProjectId, isProjectSkillName, MAX_AGENT_PROJECT_SKILL_BINDINGS, } from "./types.js";
+const MAX_SOURCE_PATH_BYTES = 16 * 1024;
+/** Thrown when resolution records fail the shape/normalization invariants below. */
+export class ProjectSkillResolutionRecordsCorruptError extends Error {
+    constructor() {
+        super("skill_projection_state_corrupt");
+        this.name = "ProjectSkillResolutionRecordsCorruptError";
+    }
+}
+const corrupt = () => { throw new ProjectSkillResolutionRecordsCorruptError(); };
+const normalizeWindowsPath = (sourcePath) => {
+    let value = sourcePath.replaceAll("/", "\\");
+    if (/^\\\\\?\\UNC\\/iu.test(value))
+        value = `\\\\${value.slice(8)}`;
+    else if (/^\\\\\?\\[A-Za-z]:\\/u.test(value))
+        value = value.slice(4);
+    if (!win32.isAbsolute(value))
+        return corrupt();
+    return win32.normalize(value).toLowerCase();
+};
+const normalizeSourcePath = (sourcePath, platform) => {
+    if (sourcePath.includes("\0") || Buffer.byteLength(sourcePath, "utf8") > MAX_SOURCE_PATH_BYTES) {
+        return corrupt();
+    }
+    if (platform === "win32")
+        return normalizeWindowsPath(sourcePath);
+    if (!posix.isAbsolute(sourcePath))
+        return corrupt();
+    return posix.normalize(sourcePath);
+};
+export function normalizeProjectSkillResolutionRecords(records, platform = process.platform) {
+    if (records.length > MAX_AGENT_PROJECT_SKILL_BINDINGS)
+        return corrupt();
+    const seen = new Set();
+    const normalized = records.map((record) => {
+        if (!isProjectId(record.projectId) || !isProjectSkillName(record.skillName))
+            return corrupt();
+        const key = `${record.projectId}\0${record.skillName}`;
+        if (seen.has(key))
+            return corrupt();
+        seen.add(key);
+        if (record.mode === "missing") {
+            if (record.sourcePath !== null)
+                return corrupt();
+            return Object.freeze({
+                projectId: record.projectId,
+                skillName: record.skillName,
+                sourcePath: null,
+                mode: "missing",
+            });
+        }
+        if (record.mode !== "resolved" || record.sourcePath === null)
+            return corrupt();
+        return Object.freeze({
+            projectId: record.projectId,
+            skillName: record.skillName,
+            sourcePath: normalizeSourcePath(record.sourcePath, platform),
+            mode: "resolved",
+        });
+    }).sort(compareProjectSkillRefs);
+    return Object.freeze(normalized);
+}

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

@@ -1,48 +1,6 @@
 import { join } from "node:path";
 import { resolveOrderedUniqueClaudeDirectories } from "../runtimes/claude.js";
 import { ProjectProjectionError, } from "./reconciler.js";
-const runtimeRootSecrets = (root) => Object.freeze([...new Set([
-        root.rootDirectory,
-        root.codexSkillRoot,
-        root.claudeAdditionalDirectory,
-        root.rootId,
-    ].flatMap((value) => [
-        value,
-        value.replaceAll("\\", "/"),
-        value.replaceAll("/", "\\"),
-    ]))].sort((left, right) => right.length - left.length));
-export function redactProjectSkillRuntimeRootText(text, root) {
-    if (root === undefined)
-        return text;
-    return runtimeRootSecrets(root)
-        .reduce((redacted, secret) => redacted.replaceAll(secret, "[project-skill-root]"), text);
-}
-export function redactProjectSkillRuntimeRootError(error, root) {
-    if (!(error instanceof Error)) {
-        return typeof error === "string" ? redactProjectSkillRuntimeRootText(error, root) : error;
-    }
-    const message = redactProjectSkillRuntimeRootText(error.message, root);
-    if (message === error.message)
-        return error;
-    const redacted = new Error(message);
-    redacted.name = error.name;
-    return redacted;
-}
-/** Recursively redacts exact v2 root identities before Runtime output crosses daemon boundaries. */
-export function redactProjectSkillRuntimeRootValue(value, root) {
-    if (root === undefined)
-        return value;
-    if (typeof value === "string")
-        return redactProjectSkillRuntimeRootText(value, root);
-    if (Array.isArray(value)) {
-        return value.map((item) => redactProjectSkillRuntimeRootValue(item, root));
-    }
-    if (typeof value === "object" && value !== null) {
-        return Object.fromEntries(Object.entries(value)
-            .map(([key, item]) => [key, redactProjectSkillRuntimeRootValue(item, root)]));
-    }
-    return value;
-}
 /** Maps one captured daemon-local root to the exact native Runtime registration seam. */
 export function projectSkillRuntimeLaunchFacts(runtime, root) {
     if (root === undefined)

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

@@ -1,6 +1,4 @@
 /** Stable, path-free console text; only logical IDs from the server snapshot are included. */
 export function formatProjectSkillRuntimeWarning(warning) {
-    return warning.code === "skill_projection_advanced"
-        ? "[runtime-warning] skill_projection_advanced"
-        : `[runtime-warning] project_skill_unavailable project=${warning.projectId} skill=${warning.skillName}`;
+    return `[runtime-warning] project_skill_unavailable project=${warning.projectId} skill=${warning.skillName}`;
 }

package/dist/project-skills/scanner.js

@@ -2,7 +2,7 @@ import { readdir, readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { compareProjectSkillRefs, isProjectSkillName, MAX_MACHINE_PROJECT_SKILLS, MAX_PROJECT_SKILL_DESCRIPTION_LENGTH, MAX_PROJECT_SKILL_FILE_BYTES, MAX_PROJECT_SKILLS_PER_PROJECT, } from "./types.js";
 import { parseSkillFrontmatter } from "../skill-frontmatter.js";
-import { computeProjectSkillBindingDigest, computeProjectSkillResolutionDigest, normalizeProjectSkillResolutionRecords, } from "./projection-state.js";
+import { normalizeProjectSkillResolutionRecords } from "./resolution-records.js";
 const unavailable = (projectId, scannedAt, errorCode) => Object.freeze({
     inventory: Object.freeze({
         projectId,
@@ -143,19 +143,3 @@ export function projectSkillResolutionRecords(bindings, projects, platform = pro
     });
     return normalizeProjectSkillResolutionRecords(records, platform);
 }
-/** Daemon-local expectation derived from one immutable scanner snapshot; no path crosses the wire. */
-export function projectSkillProjectionExpectation(snapshot, projects, platform = process.platform) {
-    const bindings = Object.freeze(snapshot.bindings
-        .map((binding) => Object.freeze({
-        projectId: binding.projectId,
-        skillName: binding.skillName,
-    }))
-        .sort(compareProjectSkillRefs));
-    const resolutions = projectSkillResolutionRecords(bindings, projects, platform);
-    return Object.freeze({
-        bindings,
-        generation: snapshot.generation,
-        bindingDigest: computeProjectSkillBindingDigest(bindings),
-        resolutionDigest: computeProjectSkillResolutionDigest(resolutions, platform),
-    });
-}

package/dist/project-skills/startup-cleanup.js

@@ -0,0 +1,24 @@
+import { cleanupLegacyProjectSkillState, sweepAllExecutionProjections } from "./legacy-cleanup.js";
+export async function runProjectSkillStartupCleanup(agentsRoot, journal, log) {
+    try {
+        const swept = await sweepAllExecutionProjections(agentsRoot, async (executionId) => {
+            const entry = await journal.get(executionId);
+            return entry !== null && entry.state !== "completed" && entry.state !== "interrupted";
+        });
+        const legacy = await cleanupLegacyProjectSkillState({ agentsRoot, journal });
+        const degraded = swept.failed > 0 || legacy.failedAgents.length > 0 || legacy.keptStores.length > 0;
+        log("project_skills.startup_cleanup", "启动清扫执行投影与旧运行时状态", {
+            removed_projections: swept.removed, kept_projections: swept.kept,
+            failed_projection_sweeps: swept.failed,
+            removed_legacy_stores: legacy.removedStores.length, kept_legacy_stores: legacy.keptStores.length,
+            failed_legacy_agents: legacy.failedAgents.length,
+            removed_shared_entries: legacy.removedSharedEntries,
+            ...(degraded ? { level: "WARN" } : {}),
+        });
+    }
+    catch (error) {
+        log("project_skills.startup_cleanup_failed", "启动清扫失败,能力不受影响", {
+            level: "WARN", error_message: error.message,
+        });
+    }
+}

package/dist/runner.js

@@ -1,6 +1,7 @@
 /** Legacy agent orchestration around the business-neutral local executor. */
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
+import { resolveReposRoot } from "./config.js";
 import { mintAgentToken } from "./token.js";
 import { buildSystemPrompt, buildWakePrompt, capMemoryForInject, capWorkLogForInject } from "./prompt.js";
 import { deliverScheduledReport, } from "./scheduled-report.js";
@@ -84,7 +85,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
             token: credential.token,
             agentId: credential.agentId,
             agentsRoot: config.agentsRoot,
-            ...(config.reposRoot === undefined ? {} : { reposRoot: config.reposRoot }),
+            reposRoot: resolveReposRoot(config.agentsRoot, config.reposRoot),
             ...(config.qaReportRoot === undefined ? {} : { qaReportRoot: config.qaReportRoot }),
             cliPath: config.cliPath,
             providerConfig,

package/dist/serve.js

@@ -8,7 +8,8 @@ import { randomUUID } from "node:crypto";
 import { dslog, setSlogDefaults, drainSpool, flushSlog } from "./slog.js";
 import { mergeRunAgentResults, reportScheduledStartFailure, runAgent } from "./runner.js";
 import { buildOriginDecisionRetryPrompt, buildScheduledPrompt } from "./prompt.js";
-import { collectMachineHello, daemonCapabilities, detectExecutionRuntimesWithSignal, } from "./machine-info.js";
+import { collectMachineHello, daemonCapabilities, daemonCapabilityBindings, detectExecutionRuntimesWithSignal, } from "./machine-info.js";
+import { reconcileExecutionJournal } from "./execution-recovery.js";
 import { initReleaseSlog, reportDaemonConnectionClose, reportReleaseError } from "./release-channel-guard.js";
 import { conservativeExecutionRuntimes, createRuntimeProbeCoordinator, } from "./runtime-probe.js";
 import { listWorkspace, readWorkspaceFile } from "./workspace-fs.js";
@@ -19,6 +20,7 @@ import { normalizeScheduledContext } from "./scheduled-report.js";
 import { formatDaemonLogLine } from "./log-format.js";
 import { reportAgentRunComplete } from "./scheduled-run-report.js";
 import { runWithOriginDecisionGuard } from "./origin-decision.js";
+import { createExecutionJournal } from "./execution-journal.js";
 import { createExecutionTelemetryJournal } from "./execution-telemetry-journal.js";
 import { ExecutionRejectedSchema, ExecutionSnapshotSchema, LegacyAgentStartSchema, ServerToDaemonExecutionFrameSchema, } from "./execution-protocol.js";
 import { hashExecutionSpec, projectWorkspaceCapabilityRejection, runExecution, } from "./execution-runner.js";
@@ -40,10 +42,8 @@ import { createProjectRegistryWiring } from "./project-registry-wiring.js";
 import { createProjectSkillsController, } from "./project-skills/controller.js";
 import { PROJECT_SKILLS_CAPABILITY } from "./project-skills/types.js";
 import { createAgentProjectionCoordinator } from "./project-skills/agent-projection-coordinator.js";
-import { createProjectSkillRuntimeRootStartup, } from "./project-skills/runtime-root-startup.js";
-import { createProjectSkillControllerReadiness, withProjectSkillCapabilityStatus } from "./project-skills/capability.js";
-import { initializeProjectSkillProtectedExecutionJournal } from "./project-skills/serve-startup.js";
-import { createProjectSkillConnectionCapabilityProvider, createProjectSkillMachineHelloPublisher } from "./project-skills/serve-capability.js";
+import { createMachineHelloPublisher } from "./project-skills/machine-hello-publisher.js";
+import { runProjectSkillStartupCleanup } from "./project-skills/startup-cleanup.js";
 import { createAgentAbilityRuntime } from "./agent-ability/runtime.js";
 import { createProjectSkillsReconciler, } from "./project-skills/reconciler.js";
 import { initializedProjectSkillsReconciler } from "./project-skills/initialized-reconciler.js";
@@ -53,6 +53,7 @@ import { handleRuntimeHealthProbeFrame } from "./runtime-health-handler.js";
 import { buildControlPlaneUrl } from "./control-plane-url.js";
 import { createServeMigrationController, handleMigrationControlMessage } from "./daemon-migration-wiring.js";
 import { createCodexHomeModeController } from "./codex-home-mode-controller.js";
+import { resolveDaemonLocalStateRootFromEnv } from "./daemon-local-home.js";
 import { attachStorageMigrationRuntime, createServeStorageStatusDelivery, handleStorageMigrationControl, replayStorageMigrationStatus, storageMigrationCapabilities, } from "./storage-serve-adapter.js";
 export { buildControlPlaneUrl } from "./control-plane-url.js";
 // normalize.ts 的活动种类 → activity 枚举
@@ -75,7 +76,6 @@ export function serve(config, opts = {}) {
     let stopPromise = null;
     let executionJournal;
     const injectedExecutionJournal = opts.execution?.journal;
-    const protectedExecutionIds = new Set();
     const agentMemory = opts.execution?.dependencies?.agentMemory
         ?? (config.agentMemory === null ? undefined : createAgentMemoryBridge(config.agentMemory));
     const executionTelemetry = createExecutionTelemetryJournal(config.agentsRoot);
@@ -83,8 +83,10 @@ export function serve(config, opts = {}) {
     let detectedExecutionRuntimes = [], executionRuntimesKnown = false;
     let runtimeFacts = null;
     const runtimeProbe = createRuntimeProbeCoordinator();
+    const localHome = opts.localHome ?? resolveDaemonLocalStateRootFromEnv();
     const hostCoordinator = opts.execution?.hostCoordinator
         ?? createHostExecutionCoordinator({
+            localHome,
             executionSlots: config.executionLimits.maxParallelTotal,
             startupSlots: config.executionLimits.maxStartingTotal,
             startupGapMs: config.executionLimits.startupGapMs,
@@ -151,9 +153,10 @@ export function serve(config, opts = {}) {
     let projectSkillsController;
     const projectSkillsReconciler = opts.projectSkills?.reconciler ?? createProjectSkillsReconciler({
         agentsRoot: config.agentsRoot,
-        coordinator: projectionCoordinator,
         scannedProjects: () => projectSkillsController.scannedProjects(),
-        protectedExecutionIds,
+        onCleanupFailed: (executionId, error) => dslog("project_skills.cleanup_failed", "执行投影目录清理失败,留待下次启动清扫", {
+            level: "WARN", execution_id: executionId, error_code: error.code ?? "unknown",
+        }),
     });
     projectSkillsController = opts.projectSkills?.controller ?? createProjectSkillsController({
         registry: projectRegistry,
@@ -168,30 +171,21 @@ export function serve(config, opts = {}) {
         },
         isAdmissionClosed: () => storageMigrationAdmissionClosed(),
         reconcile: (handle, bindings) => projectSkillsReconciler.reconcile(handle, bindings),
-        ensureSnapshot: (handle, snapshot, options) => projectSkillsReconciler.ensureSnapshot(handle, snapshot, options),
     });
-    const projectSkillRuntimeRootStartup = opts.projectSkills?.runtimeRootStartup
-        ?? createProjectSkillRuntimeRootStartup();
-    const projectSkillControllerReadiness = createProjectSkillControllerReadiness({
-        initialize: () => projectSkillsController.initialize(),
-        onUnavailable: (error) => dslog("project_skills.registry_failed", "本机项目注册表读取失败", {
-            level: "ERROR", error_code: error.code ?? "project_registry_corrupt",
-        }),
-        onSettled: () => machineHelloPublisher.republish(),
+    const logRegistryFailure = (error) => dslog("project_skills.registry_failed", "本机项目注册表读取失败,本次不上报项目清单(能力不受影响)", {
+        level: "ERROR", error_code: error.code ?? "project_registry_corrupt",
     });
-    const machineHelloPublisher = createProjectSkillMachineHelloPublisher({
-        status: projectSkillControllerReadiness.status,
-        effective: (hello, status) => {
-            const effective = withProjectSkillCapabilityStatus(hello, status);
+    const machineHelloPublisher = createMachineHelloPublisher({
+        effective: (hello) => {
             const configuredIdentity = opts.storageMigration?.identity;
             const currentIdentity = typeof configuredIdentity === "function"
                 ? configuredIdentity()
                 : configuredIdentity;
-            return currentIdentity === undefined ? effective : { ...effective, ...currentIdentity };
+            return currentIdentity === undefined ? hello : { ...hello, ...currentIdentity };
         },
         onSent: (hello) => log(`📤 已上报机器信息: ${hello.hostname} · ${hello.os} · installed=[${hello.runtimes.join(",")}] · executable=[${hello.executionRuntimes.join(",")}] · agents=[${hello.agentHandles.join(",")}]`),
     });
-    const initializedProjectSkills = initializedProjectSkillsReconciler(projectSkillControllerReadiness.ensure, projectSkillsReconciler);
+    const initializedProjectSkills = initializedProjectSkillsReconciler(() => projectSkillsController.ensureScanned(), projectSkillsReconciler);
     const configuredCapabilities = opts.machineInfo?.capabilities ?? daemonCapabilities(process.platform);
     const storageCapabilities = storageMigrationCapabilities(configuredCapabilities, opts.storageMigration);
     const storageStatusDelivery = createServeStorageStatusDelivery(opts.storageMigration, {
@@ -209,17 +203,7 @@ export function serve(config, opts = {}) {
         sendStatus: storageStatusDelivery.send,
     });
     storageMigrationAdmissionClosed = storageMigrationRuntime.isAdmissionClosed;
-    const prepareProjectSkillCapabilities = createProjectSkillConnectionCapabilityProvider({
-        platform: process.platform,
-        baseCapabilities: storageCapabilities,
-        additionalCapabilities: () => managedDaemonCapabilities(updateEligibility),
-        probeRuntimeRootStorePrimitive: projectSkillRuntimeRootStartup.probeNativePublicationPrimitiveReadiness,
-        initializeController: projectSkillControllerReadiness.ensure,
-        recoverRuntimeRootsAndLeases: async () => projectSkillRuntimeRootStartup
-            .recover(config.agentsRoot, executionJournal, protectedExecutionIds)
-            .then(() => true, () => false),
-        applyReadiness: projectSkillControllerReadiness.applyPreflight,
-    });
+    const prepareCapabilities = async () => daemonCapabilityBindings(process.platform, [...storageCapabilities, ...await managedDaemonCapabilities(updateEligibility)]);
     const safeExecutionSend = (frame) => {
         try {
             if (ws?.readyState !== WebSocket.OPEN)
@@ -324,10 +308,10 @@ export function serve(config, opts = {}) {
     async function connect() {
         if (stopped)
             return;
-        const capabilities = await prepareProjectSkillCapabilities();
+        const capabilities = await prepareCapabilities();
         if (stopped)
             return;
-        const wsUrl = (opts.buildControlPlaneUrl ?? buildControlPlaneUrl)(config.serverUrl, config.machineToken, process.platform, undefined, projectSkillControllerReadiness.status() === "ready", capabilities.controlPlaneUrl);
+        const wsUrl = (opts.buildControlPlaneUrl ?? buildControlPlaneUrl)(config.serverUrl, config.machineToken, process.platform, undefined, capabilities.controlPlaneUrl);
         ws = createWebSocket(wsUrl);
         let connectionEpochToken;
         ws.on("open", () => {
@@ -827,9 +811,9 @@ export function serve(config, opts = {}) {
                 // ready 帧带 server 视角的 machineId/workspaceId → 作为后续所有日志的默认关联键
                 const r = msg;
                 setSlogDefaults({ machine_id: r.machineId, workspace_id: r.workspaceId });
-                if (opts.storageMigration?.ready === true && typeof r.workspaceId === "string") {
+                if (opts.storageMigration?.ready === true && typeof r.workspaceId === "string" && typeof r.machineId === "string") {
                     try {
-                        opts.storageMigration.bindServerIdentity?.({ workspaceId: r.workspaceId });
+                        opts.storageMigration.bindServerIdentity?.({ workspaceId: r.workspaceId, machineId: r.machineId });
                         machineHelloPublisher.republish();
                     }
                     catch (error) {
@@ -843,8 +827,9 @@ export function serve(config, opts = {}) {
                     ? r.serverCapabilities.filter((c) => typeof c === "string")
                     : []);
                 if (serverCapabilities.has(PROJECT_SKILLS_CAPABILITY)) {
-                    if (await projectSkillControllerReadiness.ensure())
-                        await projectSkillsController.publishCurrent();
+                    void projectSkillsController.initialize()
+                        .then(() => projectSkillsController.publishCurrent())
+                        .catch(logRegistryFailure);
                 }
                 return;
             }
@@ -869,10 +854,6 @@ export function serve(config, opts = {}) {
                 const result = serverCapabilities.has(PROJECT_SKILLS_CAPABILITY)
                     ? await projectSkillsController.handle(msg, connectionEpochToken)
                     : { ok: false, error: "capability_unavailable" };
-                if (result.ok && (msg.type === "project:remove"
-                    || msg.type === "project:rescan")) {
-                    void projectSkillControllerReadiness.ensure();
-                }
                 try {
                     ws?.send(JSON.stringify({ type: "fs:result", reqId: request.reqId, ...result }));
                 }
@@ -1335,13 +1316,32 @@ export function serve(config, opts = {}) {
         });
     }
     const ready = (async () => {
-        executionJournal = await initializeProjectSkillProtectedExecutionJournal({
-            config,
+        executionJournal = injectedExecutionJournal ?? createExecutionJournal(config.agentsRoot, {
+            onOperationTiming: (event) => {
+                if (event.operation !== "mark_runtime_ready"
+                    && event.queueWaitMs < 250
+                    && event.operationMs < 250)
+                    return;
+                dslog("execution.journal_operation", "execution journal 操作完成", {
+                    level: event.outcome === "succeeded" ? "INFO" : "ERROR",
+                    execution_id: event.executionId,
+                    operation: event.operation,
+                    outcome: event.outcome,
+                    queue_wait_ms: event.queueWaitMs,
+                    operation_ms: event.operationMs,
+                    total_ms: event.queueWaitMs + event.operationMs,
+                });
+            },
+        });
+        await reconcileExecutionJournal(executionJournal, {
+            agentsRoot: config.agentsRoot,
+            serverUrl: config.serverUrl,
             ...(opts.profileName === undefined ? {} : { profileName: opts.profileName }),
-            startup: projectSkillRuntimeRootStartup,
-            protectedExecutionIds,
-            ...(injectedExecutionJournal === undefined ? {} : { injectedJournal: injectedExecutionJournal }),
+            log: dslog,
+            flush: flushSlog,
+            writeStderr: (line) => process.stderr.write(line),
         });
+        await runProjectSkillStartupCleanup(config.agentsRoot, executionJournal, dslog);
         await connect();
     })();
     const stop = () => {

package/dist/slog.js

@@ -15,6 +15,7 @@ import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { createHash } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync } from "node:fs";
+import { resolveDaemonLocalStateRoot } from "./daemon-local-home.js";
 const FLUSH_INTERVAL_MS = 1500;
 const BATCH_SIZE = 50;
 const SPOOL_MAX_FILES = 50; // spool 目录文件数上限,超出丢最旧(日志非关键数据,防无限膨胀)
@@ -27,6 +28,7 @@ let flushPromise = null;
 let inFlightBatch = [];
 let lastErrorAt = 0;
 let exitHookInstalled = false;
+let localStateRoot;
 function deploymentEnvironment(serverHost) {
     if (serverHost === "nowwork-in.nowcoder.com")
         return "prod";
@@ -40,12 +42,23 @@ function deploymentEnvironment(serverHost) {
     return "unknown";
 }
 function spoolDir() {
-    return process.env.CREW_SLS_SPOOL_DIR ?? join(homedir(), ".crew", "logs", "sls-spool");
+    return process.env.CREW_SLS_SPOOL_DIR ?? join(localStateRoot ?? resolveDaemonLocalStateRoot({
+        userHome: homedir(),
+        platform: process.platform,
+        explicit: process.env.NOWWORK_LOCAL_HOME,
+        mode: process.env.NOWWORK_LOCAL_HOME_MODE ?? process.env.NOWWORK_STORAGE_MODE,
+    }), "logs", "sls-spool");
 }
 /** serve/run 启动时调用一次;disabled(CREW_SLS_LOG=off)则保持 no-op。 */
 export function initSlog(serverUrl, machineToken, identity = {}) {
     if (process.env.CREW_SLS_LOG === "off" || process.env.CREW_SLS_LOG === "0")
         return;
+    localStateRoot = resolveDaemonLocalStateRoot({
+        userHome: homedir(),
+        platform: process.platform,
+        explicit: process.env.NOWWORK_LOCAL_HOME,
+        mode: process.env.NOWWORK_LOCAL_HOME_MODE ?? process.env.NOWWORK_STORAGE_MODE,
+    });
     cfg = { serverUrl: serverUrl.replace(/\/+$/, ""), token: machineToken };
     let serverHost;
     try {

package/dist/storage-control.js

@@ -5,6 +5,8 @@ const IdentitySchema = z.object({
     migrationId: z.string().uuid(),
     environment: z.string().regex(/^[a-z0-9][a-z0-9_-]{0,31}$/u),
     workspaceId: z.string().uuid(),
+    ownerEpoch: z.number().int().positive().safe().optional(),
+    ownershipClaimFingerprint: z.string().regex(/^sha256:[0-9a-f]{64}$/u).optional(),
 });
 const DoctorRequestSchema = IdentitySchema.extend({ type: z.literal("daemon:storage-doctor") }).strict();
 const MigrateRequestSchema = IdentitySchema.extend({
@@ -26,6 +28,11 @@ export function createStorageControlController(input) {
     const profile = z.string().regex(/^[a-z0-9][a-z0-9_-]{0,47}$/u).parse(input.profile);
     const sourceStorageFingerprint = z.string().regex(/^sha256:[0-9a-f]{64}$/u).parse(input.sourceStorageFingerprint);
     const targetStorageFingerprint = z.string().regex(/^sha256:[0-9a-f]{64}$/u).parse(input.targetStorageFingerprint);
+    const ownership = input.ownership === undefined ? undefined : Object.freeze({
+        ownerEpoch: z.number().int().positive().safe().parse(input.ownership.ownerEpoch),
+        ownershipClaimFingerprint: z.string().regex(/^sha256:[0-9a-f]{64}$/u)
+            .parse(input.ownership.ownershipClaimFingerprint),
+    });
     const preflights = new Map();
     const preflightRuns = new Map();
     const appliedMigrationIds = new Set();
@@ -39,6 +46,7 @@ export function createStorageControlController(input) {
         environment,
         workspaceId,
         profile,
+        ...(ownership === undefined ? {} : ownership),
         ...extra,
     });
     const failure = (identity, errorCode, error, reopenAdmission = false, extra = {}) => {
@@ -59,7 +67,10 @@ export function createStorageControlController(input) {
             input.onStatusError?.(error, statusFrame);
         }
     };
-    const matchesIdentity = (identity) => identity.environment === environment && identity.workspaceId === workspaceId;
+    const matchesIdentity = (identity) => identity.environment === environment && identity.workspaceId === workspaceId
+        && (ownership === undefined
+            || (identity.ownerEpoch === ownership.ownerEpoch
+                && identity.ownershipClaimFingerprint === ownership.ownershipClaimFingerprint));
     const preflightKey = (identity) => `${identity.migrationId}\0${identity.environment}\0${identity.workspaceId}`;
     const runPreflight = (identity, failureFallback = "doctor_failed") => {
         const key = preflightKey(identity);

package/dist/storage-identity.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { STORAGE_LAYOUT_VERSION } from "./storage-layout.js";
+import { createStorageOwnershipClaim } from "./storage-ownership.js";
 function fingerprint(namespace, value) {
     return `sha256:${createHash("sha256").update(`${namespace}\0${value}`).digest("hex")}`;
 }
@@ -14,14 +15,27 @@ export function storageHelloIdentity(input) {
         || installation.runtimeRoot !== layout.runtimeRoot) {
         throw new Error("installation storage identity does not match resolved layout");
     }
+    const workspaceRootFingerprint = fingerprint("workspace-root", layout.workspaceRoot);
+    let ownership;
+    if (input.ownership !== undefined) {
+        const { claimFingerprint: reportedFingerprint, ...claimIdentity } = input.ownership;
+        ownership = createStorageOwnershipClaim(claimIdentity);
+        if (ownership.claimFingerprint !== reportedFingerprint
+            || ownership.workspaceId !== layout.workspaceId
+            || ownership.environment !== layout.environment
+            || ownership.workspaceRootFingerprint !== workspaceRootFingerprint) {
+            throw new Error("storage ownership identity does not match resolved layout");
+        }
+    }
     return Object.freeze({
         storageLayoutVersion: STORAGE_LAYOUT_VERSION,
         storageEnvironment: layout.environment,
         storageWorkspaceId: layout.workspaceId,
         storageIdFingerprint: storageIdFingerprint(installation.storageId),
-        workspaceRootFingerprint: fingerprint("workspace-root", layout.workspaceRoot),
+        workspaceRootFingerprint,
         daemonRootFingerprint: fingerprint("daemon-root", layout.daemonRoot),
         agentRootFingerprint: fingerprint("agent-root", layout.agentItemsRoot),
+        ...(ownership === undefined ? {} : { storageOwnership: ownership }),
         ...(installation.storageMigrationId === undefined
             ? {}
             : { storageMigrationId: installation.storageMigrationId }),

package/dist/storage-migration-controller.js

@@ -27,6 +27,8 @@ const ReceiptSchema = z.object({
     environment: z.string().min(1),
     workspaceId: z.string().uuid(),
     profile: z.string().regex(/^[a-z0-9][a-z0-9_-]{0,47}$/u),
+    ownerEpoch: z.number().int().positive().safe().optional(),
+    ownershipClaimFingerprint: z.string().regex(/^sha256:[0-9a-f]{64}$/u).optional(),
     manifestDigest: z.string().regex(/^[0-9a-f]{64}$/u),
     targetFingerprint: z.string().regex(/^sha256:[0-9a-f]{64}$/u),
     status: ReceiptStatusSchema,
@@ -37,13 +39,23 @@ const ReceiptSchema = z.object({
     sourceStopAttempted: z.boolean().optional(),
     sourceStopped: z.boolean().optional(),
     targetTouched: z.boolean().optional(),
-}).strict();
+}).strict().superRefine((receipt, context) => {
+    if ((receipt.ownerEpoch === undefined) !== (receipt.ownershipClaimFingerprint === undefined)) {
+        context.addIssue({ code: z.ZodIssueCode.custom, message: "storage receipt ownership identity must be complete" });
+    }
+});
 const MigrationLockSchema = z.object({
     version: z.literal(1),
     migrationId: z.string().uuid(),
     pid: z.number().int().positive(),
     createdAt: z.string().datetime({ offset: true }),
 }).strict();
+const REQUIRED_BACKUP_ARTIFACTS = Object.freeze([
+    "profile.json",
+    "service-descriptor",
+    "managed-service-registry.json",
+    "installations.json",
+]);
 export class StorageMigrationFailure extends Error {
     code;
     receipt;
@@ -204,6 +216,16 @@ function assertOwnedStaging(input) {
     }
 }
 async function backupArtifacts(input, receipt) {
+    const providedNames = new Set(input.backupArtifacts.map((artifact) => artifact.name));
+    const missing = REQUIRED_BACKUP_ARTIFACTS.filter((name) => !providedNames.has(name));
+    if (missing.length > 0) {
+        throw new StorageMigrationFailure("backup_artifact_missing", `required rollback artifacts are missing: ${missing.join(", ")}`);
+    }
+    for (const artifact of input.backupArtifacts) {
+        if (!(await lstat(artifact.path)).isFile()) {
+            throw new StorageMigrationFailure("backup_artifact_invalid", "backup artifact must be a file");
+        }
+    }
     const directory = join(input.backupsRoot, receipt.migrationId);
     const artifactsDirectory = join(directory, "artifacts");
     await mkdir(artifactsDirectory, { recursive: true, mode: 0o700 });
@@ -217,8 +239,6 @@ async function backupArtifacts(input, receipt) {
             throw new StorageMigrationFailure("backup_artifact_invalid", "backup artifact names must be unique safe file names");
         }
         names.add(artifact.name);
-        if (!(await lstat(artifact.path)).isFile())
-            throw new StorageMigrationFailure("backup_artifact_invalid", "backup artifact must be a file");
         const destination = join(artifactsDirectory, artifact.name);
         await copyFile(artifact.path, destination);
         await chmod(destination, 0o600);
@@ -271,6 +291,7 @@ export async function runStorageMigration(input, dependencies) {
         environment: input.doctor.environment,
         workspaceId: input.doctor.workspaceId,
         profile: input.doctor.profile,
+        ...(input.ownership === undefined ? {} : input.ownership),
         manifestDigest: input.doctor.manifestDigest,
         targetFingerprint: targetFingerprint(input.targetWorkspaceRoot),
         status: "preflight_passed",
@@ -301,7 +322,7 @@ export async function runStorageMigration(input, dependencies) {
         input.assertHealthy?.();
         await transition("backing_up");
         receipt = await backupArtifacts(input, receipt).catch((error) => {
-            failureCode = "backup_failed";
+            failureCode = error instanceof StorageMigrationFailure ? error.code : "backup_failed";
             throw error;
         });
         await writeReceipt(path, receipt);