@nowcrew/daemon 0.6.41 → 0.6.42

package/dist/config.js

@@ -15,13 +15,10 @@ export const DEFAULT_EXECUTION_LIMITS = Object.freeze({
     maxQueuedPerAgent: 32,
     maxParallelTotal: 10,
     maxQueuedTotal: 128,
-    maxStartingTotal: 10,
-    maxStartingPerRuntime: 10,
-    startupGapMs: 500,
+    maxStartingTotal: 1,
+    maxStartingPerRuntime: 1,
+    startupGapMs: 3_000,
     startupTimeoutMs: 120_000,
-    maxQueueWaitMs: 5 * 60_000,
-    maxFirstOutputWaitMs: 2 * 60_000,
-    firstOutputGraceMs: 3 * 60_000,
 });
 // Fits the largest mandatory v1 lifecycle envelope (UUID + timestamps + outcome facts) with margin.
 export const MIN_EXECUTION_EVENT_BYTES = 512;
@@ -88,9 +85,6 @@ export function loadConfig(env = process.env) {
         maxStartingPerRuntime: positiveIntegerEnv(env, "CREW_EXECUTION_MAX_STARTING_PER_RUNTIME", DEFAULT_EXECUTION_LIMITS.maxStartingPerRuntime),
         startupGapMs: positiveIntegerEnv(env, "CREW_EXECUTION_START_GAP_MS", DEFAULT_EXECUTION_LIMITS.startupGapMs),
         startupTimeoutMs: positiveIntegerEnv(env, "CREW_EXECUTION_STARTUP_TIMEOUT_MS", DEFAULT_EXECUTION_LIMITS.startupTimeoutMs),
-        maxQueueWaitMs: positiveIntegerEnv(env, "CREW_EXECUTION_MAX_QUEUE_WAIT_MS", DEFAULT_EXECUTION_LIMITS.maxQueueWaitMs),
-        maxFirstOutputWaitMs: positiveIntegerEnv(env, "CREW_EXECUTION_MAX_FIRST_OUTPUT_WAIT_MS", DEFAULT_EXECUTION_LIMITS.maxFirstOutputWaitMs),
-        firstOutputGraceMs: positiveIntegerEnv(env, "CREW_EXECUTION_FIRST_OUTPUT_GRACE_MS", DEFAULT_EXECUTION_LIMITS.firstOutputGraceMs),
     });
     return {
         serverUrl,

package/dist/execution-runner.js

@@ -4,7 +4,7 @@ import { DaemonToServerExecutionFrameSchema, ExecutionCompletedSchema, Execution
 import { JournalConflictError } from "./execution-journal.js";
 import { boundExecutionFrame } from "./execution-event-limit.js";
 import { mintAgentToken } from "./token.js";
-import { executeLocal, RuntimeRunningCallbackTimeoutError, withLocalExecutionFacts, } from "./local-executor.js";
+import { executeLocal, withLocalExecutionFacts, } from "./local-executor.js";
 import { startDormantSupervisor, } from "./execution-supervisor.js";
 import { CLAUDE_EFFORT_LEVELS } from "./runtimes/claude.js";
 import { CODEX_EFFORT_LEVELS } from "./runtimes/codex.js";
@@ -12,17 +12,18 @@ import { KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
 import { executionBackendCapability } from "./execution-backend.js";
 import { readBoundImDecisionFile, resetBoundImDecisionFile } from "./bound-im-decision.js";
 import { RuntimeCancelledError } from "./runtime-cancellation.js";
+import { HostReservationCancelledError } from "./host-execution-coordinator.js";
 import { supervisorLaunch } from "./supervised-runtime.js";
 import { appendAgentMemoryContext } from "./agent-memory/policy.js";
 import { ProjectSkillRuntimeOwnershipUnverifiedError, } from "./project-skills/reconciler.js";
 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";
 import { dslog } from "./slog.js";
+import { identityRosterPromptFacts } from "./identity-roster-telemetry.js";
 export { supervisorLaunch } from "./supervised-runtime.js";
 const ACTIVITY_KIND = {
     init: "working",
@@ -297,12 +298,6 @@ class ExecutionCancelledError extends Error {
         this.name = "ExecutionCancelledError";
     }
 }
-class ExecutionQueueTimeoutError extends Error {
-    constructor(timeoutMs) {
-        super(`Execution queue wait exceeded ${timeoutMs}ms`);
-        this.name = "ExecutionQueueTimeoutError";
-    }
-}
 async function cancellable(promise, cancellation) {
     if (cancellation === undefined)
         return promise;
@@ -313,30 +308,13 @@ async function cancellable(promise, cancellation) {
         cancellation.requested.then(() => { throw new ExecutionCancelledError(); }),
     ]);
 }
-async function cancellableWithTimeout(promise, timeoutMs, cancellation, timeoutError) {
-    let timer;
-    try {
-        return await Promise.race([
-            cancellable(promise, cancellation),
-            new Promise((_resolve, reject) => {
-                timer = setTimeout(() => reject(timeoutError), timeoutMs);
-            }),
-        ]);
-    }
-    finally {
-        if (timer !== undefined)
-            clearTimeout(timer);
-    }
-}
 function failedCompletion(spec, error, startedAt, finishedAt) {
     const message = error instanceof Error ? error.message : String(error);
-    const errorCode = error instanceof ExecutionQueueTimeoutError
+    const errorCode = error instanceof HostReservationCancelledError
         ? "queue_timeout"
         : error instanceof ProjectContextUnavailableError
             ? error.code
-            : error instanceof ProjectDependencyError
-                ? error.code
-                : projectSkillProjectionErrorCode(error) ?? "local_execution_failed";
+            : projectSkillProjectionErrorCode(error) ?? "local_execution_failed";
     return ExecutionCompletedSchema.parse({
         type: "execution:completed",
         protocolVersion: 1,
@@ -367,6 +345,15 @@ export async function runExecution(config, input, dependencies) {
         return { kind: "rejected", frame };
     }
     const spec = parsed.data;
+    dslog("execution.identity_roster_received", "daemon 已收到执行提示词中的工作区身份名册", {
+        execution_id: spec.executionId,
+        agent_handle: spec.agent.handle,
+        channel_id: spec.context.channelId,
+        thread_id: spec.context.threadId,
+        wake_message_id: spec.context.wakeMessageId,
+        runtime: spec.runtime.name,
+        ...identityRosterPromptFacts(spec.instructions.systemPrompt),
+    });
     const capabilityRejection = projectWorkspaceCapabilityRejection(spec, dependencies.capabilities, initialAt);
     if (capabilityRejection !== null) {
         const frame = ExecutionRejectedSchema.parse(boundExecutionFrame(capabilityRejection, config.executionLimits.maxEventBytes));
@@ -411,7 +398,6 @@ export async function runExecution(config, input, dependencies) {
         return { kind: "rejected", frame };
     }
     const { permission } = checked;
-    const effectiveTimeoutMs = spec.runtime.timeoutMs ?? config.executionLimits.maxTimeoutMs;
     const accepted = await dependencies.journal.accept(spec.executionId, specHash, {
         runtime: spec.runtime.name,
         ...(spec.runtime.model === undefined ? {} : { model: spec.runtime.model }),
@@ -480,12 +466,7 @@ export async function runExecution(config, input, dependencies) {
     };
     let startedAt = accepted.acceptedAt;
     let runtimeCancel = null;
-    let timeout;
-    let firstOutputTimer;
-    let timedOut = false;
-    let firstOutputTimedOut = false;
     let completion;
-    let abandonedRuntimeRunningCompletion = null;
     let memoryCaptureFinalText = null;
     let boundImDecision = spec.reporting.allowBoundImDecision
         ? "silent"
@@ -496,24 +477,11 @@ export async function runExecution(config, input, dependencies) {
     });
     try {
         if (dependencies.slot !== undefined) {
-            await cancellableWithTimeout(dependencies.slot.ready, config.executionLimits.maxQueueWaitMs, dependencies.cancellation, new ExecutionQueueTimeoutError(config.executionLimits.maxQueueWaitMs));
+            await cancellable(dependencies.slot.ready, dependencies.cancellation);
         }
         let projectContext;
         let sessionContextFingerprint;
         const logicalProjectContext = spec.workspace.projectContext;
-        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
-                && logicalProjectContext !== undefined
-                && logicalProjectContext.projectIds.length > 0,
-        });
         if (logicalProjectContext !== undefined && logicalProjectContext.projectIds.length > 0) {
             const projectSnapshot = {
                 projectIds: logicalProjectContext.projectIds,
@@ -521,50 +489,7 @@ export async function runExecution(config, input, dependencies) {
                     ? {}
                     : { primaryProjectId: logicalProjectContext.primaryProjectId }),
             };
-            const projectWorkspaceRegistry = dependencies.projectWorkspaceRegistry
-                ?? dependencies.projectRegistry
-                ?? createProjectRegistry(config.agentsRoot);
-            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"),
-                    projectsRoot: join(config.agentsRoot, "Projects"),
-                    projectIds: projectSnapshot.projectIds,
-                }), dependencies.cancellation);
-                for (const project of preparedProjectDependencies) {
-                    dslog("project_dependencies.prepared", "Training project dependency prepared", {
-                        execution_id: spec.executionId,
-                        agent_handle: spec.agent.handle,
-                        project_id: project.projectId,
-                        project_branch: project.branch,
-                        project_branch_source: project.branchSource,
-                        project_commit: project.resolvedCommit,
-                        project_checkout_mode: project.checkoutMode,
-                    });
-                }
-            }
-            else if (spec.agent.abilityRelease === undefined) {
-                dslog("project_dependencies.skipped", "缺少 abilityRelease，未执行项目依赖准备", {
-                    level: "WARN",
-                    execution_id: spec.executionId,
-                    agent_handle: spec.agent.handle,
-                    project_ids: JSON.stringify(projectSnapshot.projectIds),
-                    reason: "ability_release_missing",
-                });
-            }
-            else {
-                dslog("project_dependencies.skipped", "Daemon 未提供项目依赖准备器", {
-                    level: "WARN",
-                    execution_id: spec.executionId,
-                    agent_handle: spec.agent.handle,
-                    project_ids: JSON.stringify(projectSnapshot.projectIds),
-                    ability_release_id: spec.agent.abilityRelease.releaseId,
-                    reason: "provisioner_missing",
-                });
-            }
-            projectContext = await cancellable(resolveProjectContext(projectSnapshot, projectWorkspaceRegistry), dependencies.cancellation);
+            projectContext = await cancellable(resolveProjectContext(projectSnapshot, dependencies.projectWorkspaceRegistry ?? createProjectRegistry(config.agentsRoot)), dependencies.cancellation);
             sessionContextFingerprint = projectSessionContextFingerprint(spec.runtime.name, projectSnapshot);
         }
         let recalledMemory = "";
@@ -583,88 +508,23 @@ export async function runExecution(config, input, dependencies) {
         let consoleSequence = 0;
         let externalOutputSequence = 0;
         const callbacks = {
-            onRuntimeStarting: () => {
-                dependencies.onRuntimePhase?.("starting", spec.runtime.name);
-            },
-            onRuntimeRunning: async () => {
-                const callbackStartedAt = Date.now();
-                let callbackStage = "journal";
+            onRuntimeReady: async () => {
                 if (dependencies.cancellation?.isRequested())
                     return;
-                const cancel = runtimeCancel;
-                if (cancel !== null && timeout === undefined && !dependencies.cancellation?.isRequested()) {
-                    if (effectiveTimeoutMs > config.executionLimits.maxFirstOutputWaitMs + config.executionLimits.firstOutputGraceMs) {
-                        firstOutputTimer = setTimeout(() => {
-                            firstOutputTimedOut = true;
-                            try {
-                                void cancel().catch(rejectCancellationFailure);
-                            }
-                            catch (error) {
-                                rejectCancellationFailure(error);
-                            }
-                        }, config.executionLimits.maxFirstOutputWaitMs + config.executionLimits.firstOutputGraceMs);
-                    }
-                    timeout = setTimeout(() => {
-                        timedOut = true;
-                        try {
-                            void cancel().catch(rejectCancellationFailure);
-                        }
-                        catch (error) {
-                            rejectCancellationFailure(error);
-                        }
-                    }, effectiveTimeoutMs);
-                }
-                dependencies.onRuntimePhase?.("running", spec.runtime.name);
-                const journalStartedAt = Date.now();
-                try {
-                    const ready = await dependencies.journal.markRuntimeReady(spec.executionId, now().toISOString());
-                    const journalMs = Date.now() - journalStartedAt;
-                    if (ready.runtimeReadyAt === null) {
-                        throw new Error(`Execution ${spec.executionId} runtime readiness was not persisted`);
-                    }
-                    if (abandonedRuntimeRunningCompletion !== null) {
-                        await dependencies.journal.complete(spec.executionId, abandonedRuntimeRunningCompletion);
-                        await dependencies.report(abandonedRuntimeRunningCompletion);
-                        return;
-                    }
-                    startedAt = ready.runtimeReadyAt;
-                    callbackStage = "started_report";
-                    const reportStartedAt = Date.now();
-                    const reportDelivered = await reportBestEffort(dependencies.report, boundExecutionFrame(DaemonToServerExecutionFrameSchema.parse({
-                        type: "execution:started",
-                        protocolVersion: 1,
-                        executionId: spec.executionId,
-                        at: startedAt,
-                    }), config.executionLimits.maxEventBytes), bestEffortTimeoutMs);
-                    dslog("execution.runtime_running_callback", "runtime-running callback 已完成", {
-                        execution_id: spec.executionId,
-                        runtime: spec.runtime.name,
-                        outcome: "succeeded",
-                        journal_ms: journalMs,
-                        started_report_ms: Date.now() - reportStartedAt,
-                        started_report_delivered: reportDelivered,
-                        callback_total_ms: Date.now() - callbackStartedAt,
-                    });
-                }
-                catch (error) {
-                    dslog("execution.runtime_running_callback", "runtime-running callback 失败", {
-                        level: "ERROR",
-                        execution_id: spec.executionId,
-                        runtime: spec.runtime.name,
-                        outcome: "failed",
-                        failed_stage: callbackStage,
-                        callback_total_ms: Date.now() - callbackStartedAt,
-                        error_message: error instanceof Error ? error.message.slice(0, 500) : String(error).slice(0, 500),
-                    });
-                    throw error;
+                const ready = await dependencies.journal.markRuntimeReady(spec.executionId, now().toISOString());
+                if (ready.runtimeReadyAt === null) {
+                    throw new Error(`Execution ${spec.executionId} runtime readiness was not persisted`);
                 }
+                startedAt = ready.runtimeReadyAt;
+                await reportBestEffort(dependencies.report, boundExecutionFrame(DaemonToServerExecutionFrameSchema.parse({
+                    type: "execution:started",
+                    protocolVersion: 1,
+                    executionId: spec.executionId,
+                    at: startedAt,
+                }), config.executionLimits.maxEventBytes), bestEffortTimeoutMs);
             },
             ...(spec.reporting.streamActivity ? {
                 onActivity: (activity) => {
-                    if (firstOutputTimer !== undefined) {
-                        clearTimeout(firstOutputTimer);
-                        firstOutputTimer = undefined;
-                    }
                     const frame = DaemonToServerExecutionFrameSchema.parse({
                         type: "execution:activity",
                         protocolVersion: 1,
@@ -683,10 +543,6 @@ export async function runExecution(config, input, dependencies) {
             } : {}),
             ...(spec.reporting.streamConsole ? {
                 onConsole: (chunk) => {
-                    if (firstOutputTimer !== undefined) {
-                        clearTimeout(firstOutputTimer);
-                        firstOutputTimer = undefined;
-                    }
                     const frame = DaemonToServerExecutionFrameSchema.parse({
                         type: "execution:console",
                         protocolVersion: 1,
@@ -706,10 +562,6 @@ export async function runExecution(config, input, dependencies) {
             } : {}),
             ...(spec.context.externalResponseSessionId || spec.context.answerStream ? {
                 onExternalOutput: (text) => {
-                    if (firstOutputTimer !== undefined) {
-                        clearTimeout(firstOutputTimer);
-                        firstOutputTimer = undefined;
-                    }
                     const frame = DaemonToServerExecutionFrameSchema.parse({
                         type: "execution:output",
                         protocolVersion: 1,
@@ -883,10 +735,6 @@ export async function runExecution(config, input, dependencies) {
             execute(localInput, callbacks, localDependencies),
             cancellationFailure,
         ]);
-        if (timeout !== undefined)
-            clearTimeout(timeout);
-        if (firstOutputTimer !== undefined)
-            clearTimeout(firstOutputTimer);
         const finishedAt = now().toISOString();
         if (result.exitCode === 0 && result.finalText?.trim())
             memoryCaptureFinalText = result.finalText;
@@ -896,32 +744,7 @@ export async function runExecution(config, input, dependencies) {
             await resetBoundImDecision(path);
             boundImDecision = selected?.decision ?? "silent";
         }
-        completion = ExecutionCompletedSchema.parse(firstOutputTimedOut ? {
-            type: "execution:completed",
-            protocolVersion: 1,
-            executionId: spec.executionId,
-            outcome: "cancelled",
-            errorCode: "runtime_no_first_output",
-            errorMessage: "Runtime produced no activity before the first-output deadline",
-            runtime: result.runtime,
-            ...(result.model === null ? {} : { model: result.model }),
-            resumed: result.resumed,
-            startedAt,
-            finishedAt,
-        } : timedOut ? {
-            type: "execution:completed",
-            protocolVersion: 1,
-            executionId: spec.executionId,
-            outcome: "cancelled",
-            errorCode: "timeout",
-            errorMessage: "Execution exceeded its local timeout",
-            runtime: result.runtime,
-            ...(result.model === null ? {} : { model: result.model }),
-            resumed: result.resumed,
-            ...(boundImDecision ? { boundImDecision } : {}),
-            startedAt,
-            finishedAt,
-        } : {
+        completion = ExecutionCompletedSchema.parse({
             type: "execution:completed",
             protocolVersion: 1,
             executionId: spec.executionId,
@@ -956,10 +779,6 @@ export async function runExecution(config, input, dependencies) {
         });
     }
     catch (error) {
-        if (timeout !== undefined)
-            clearTimeout(timeout);
-        if (firstOutputTimer !== undefined)
-            clearTimeout(firstOutputTimer);
         const cancelled = error instanceof ExecutionCancelledError || error instanceof RuntimeCancelledError;
         if (cancelled) {
             await closeLaunchGate();
@@ -976,7 +795,7 @@ export async function runExecution(config, input, dependencies) {
         else {
             await proveActiveSupervisorStopped(error, spec.agent.projectSkillBindingGeneration !== undefined);
         }
-        const failureCompletion = cancelled
+        completion = cancelled
             ? ExecutionCompletedSchema.parse({
                 type: "execution:completed",
                 protocolVersion: 1,
@@ -991,12 +810,6 @@ export async function runExecution(config, input, dependencies) {
                 finishedAt: now().toISOString(),
             })
             : failedCompletion(spec, error, startedAt, now().toISOString());
-        if (error instanceof RuntimeRunningCallbackTimeoutError) {
-            abandonedRuntimeRunningCompletion = boundExecutionFrame(failureCompletion, config.executionLimits.maxEventBytes);
-            await telemetry.closeAndDrain();
-            throw error;
-        }
-        completion = failureCompletion;
     }
     completion = boundExecutionFrame(completion, config.executionLimits.maxEventBytes);
     await telemetry.closeAndDrain();

package/dist/host-execution-coordinator.js

@@ -10,6 +10,12 @@ const HOST_STARTUP_SLOT_COUNT = 10;
 const HOST_STARTUP_GAP_MS = 500;
 const RETRY_MS = 50;
 const RELEASE_RETRY_MAX_MS = 5_000;
+export class HostReservationCancelledError extends Error {
+    name = "HostReservationCancelledError";
+    constructor(message = "host execution reservation was cancelled before it could be granted") {
+        super(message);
+    }
+}
 export function defaultHostExecutionCoordinatorRoot(userHome = homedir()) {
     // Deliberately independent of CREW_DAEMON_HOME and agentsRoot: every profile
     // owned by this OS user must share the same physical-compute safety boundary.

package/dist/identity-roster-telemetry.js

@@ -0,0 +1,37 @@
+import { dslog } from "./slog.js";
+const IDENTITY_ROSTER_OPEN = "<nowwork_workspace_identity_roster>";
+const IDENTITY_ROSTER_CLOSE = "</nowwork_workspace_identity_roster>";
+export function identityRosterPromptFacts(prompt) {
+    const start = prompt.indexOf(IDENTITY_ROSTER_OPEN);
+    if (start < 0)
+        return { identity_roster_marker_present: false };
+    const payloadStart = start + IDENTITY_ROSTER_OPEN.length;
+    const close = prompt.indexOf(IDENTITY_ROSTER_CLOSE, payloadStart);
+    const payload = prompt.slice(payloadStart, close < 0 ? prompt.length : close).trim();
+    let entryCount;
+    try {
+        const parsed = JSON.parse(payload);
+        if (Array.isArray(parsed))
+            entryCount = parsed.length;
+    }
+    catch {
+        // Keep the marker as evidence even when a malformed prompt reaches the daemon.
+    }
+    return {
+        identity_roster_marker_present: true,
+        identity_roster_section_bytes: Buffer.byteLength(payload, "utf8"),
+        ...(entryCount === undefined ? {} : { identity_roster_entry_count: entryCount }),
+    };
+}
+export function logIdentityRosterRuntimePrepared(input, runtime, prompt) {
+    dslog("execution.identity_roster_runtime_prepared", "daemon 已将工作区身份名册准备给 runtime", {
+        execution_id: input.executionId,
+        agent_handle: input.handle,
+        channel_id: input.channelId,
+        task_key: input.taskKey,
+        wake_message_id: input.wakeMessageId,
+        runtime,
+        prompt_bytes: Buffer.byteLength(prompt, "utf8"),
+        ...identityRosterPromptFacts(prompt),
+    });
+}

package/dist/local-executor.js

@@ -26,6 +26,7 @@ import { boundedDiagnosticJsonArray } from "./diagnostic-json.js";
 import { ProjectProjectionError, } from "./project-skills/reconciler.js";
 import { formatProjectSkillRuntimeWarning } from "./project-skills/runtime-warning.js";
 import { projectSkillRuntimeDirectories, redactProjectSkillRuntimeRootText, redactProjectSkillRuntimeRootValue, } from "./project-skills/runtime-launch.js";
+import { logIdentityRosterRuntimePrepared } from "./identity-roster-telemetry.js";
 import { diffMemoryPruneNotes, evaluateMemoryPrunePostcondition, inspectMemoryPruneFilesWithinDeadline, parseMemoryPruneTraceId, } from "./memory-prune-diagnostics.js";
 import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLocalMemoryDiagnosticsFailure, } from "./local-memory-telemetry.js";
 import { CodexStartupStageParser } from "./codex-startup-stage.js";
@@ -547,6 +548,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                     ? {}
                     : { memorySeedCreated: executionWorkspace.memorySeedCreated }),
             });
+            logIdentityRosterRuntimePrepared(input, runtime.name, effectiveSystemPrompt);
             if (abilityContext !== undefined) {
                 dslog("ability.execution.context_loaded", "Agent training context loaded from workspace", {
                     level: "INFO", execution_id: input.executionId, agent_handle: input.handle,

package/dist/runtimes/progress-watchdog.js

@@ -4,23 +4,11 @@ export const DEFAULT_FIRST_PROGRESS_TIMEOUT_MS = 120_000;
  * the runtime's configured total timeout remains authoritative; long-running tools are not killed
  * merely because they produce no output.
  */
-export function startFirstProgressWatchdog(onTimeout, timeoutMs = DEFAULT_FIRST_PROGRESS_TIMEOUT_MS) {
+export function startFirstProgressWatchdog(_onTimeout, timeoutMs = DEFAULT_FIRST_PROGRESS_TIMEOUT_MS) {
     if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
         throw new RangeError("First-progress timeout must be a positive finite number");
     }
-    let active = true;
-    const timer = setTimeout(() => {
-        if (!active)
-            return;
-        active = false;
-        onTimeout();
-    }, timeoutMs);
-    timer.unref?.();
-    const stop = () => {
-        if (!active)
-            return;
-        active = false;
-        clearTimeout(timer);
-    };
-    return { observe: stop, stop };
+    // Progress is observational only. Runtime tasks must not be terminated because
+    // an upstream provider is temporarily silent.
+    return { observe: () => undefined, stop: () => undefined };
 }

package/dist/workspace.js

@@ -10,7 +10,7 @@
  */
 import { mkdir, writeFile, readFile, chmod, access } from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { dslog } from "./slog.js";
 /** 文件系统安全的 taskKey:仅留 [\w.-],其余转 _,截断,避免路径穿越/超长。 */
 export function safeKey(key) {
@@ -86,6 +86,10 @@ export async function prepareWorkspace(input) {
         await mkdir(runDir, { recursive: true });
         workLogPath = join(runDir, "work-log.md");
     }
+    // The first turn legitimately has no progress yet, but the path is part of the
+    // Runtime contract and memory-prune diagnostics expect it to be inspectable.
+    await mkdir(dirname(workLogPath), { recursive: true });
+    await writeFile(workLogPath, "", { flag: "a" });
     const workLog = (await exists(workLogPath)) ? await readFile(workLogPath, "utf8") : "";
     // resumeKey 可跨不同 task cwd 维持同一底层会话；协议键用 opaque 映射,legacy 保持 safeKey。
     // 未绑定项目时保留原有分支，避免改变旧 sessionDir 与 import 语义。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.41",
+  "version": "0.6.42",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",