@nowcrew/daemon 0.6.98-beta.4 → 0.6.98

package/dist/marketplace-controller.js

@@ -1,3 +1,4 @@
+import { MaintenanceRequestSchema, MaintenanceReportSchema } from "./marketplace-maintenance-protocol.js";
 import { MarketplaceRequestSchema, marketplaceActive } from "./marketplace-protocol.js";
 import { resolveMarketplaceScopes, runMarketplaceScope } from "./marketplace-runner.js";
 export function createMarketplaceController(deps) {
@@ -11,22 +12,31 @@ export function createMarketplaceController(deps) {
         const deadline = now() + 10 * 60_000;
         let lease = null;
         try {
-            const scopes = await (deps.resolve ?? resolveMarketplaceScopes)(request.targets, deps.agentsRoot);
+            const scopes = request.type === "marketplace:operation" ? await (deps.resolve ?? resolveMarketplaceScopes)(request.targets, deps.agentsRoot) : [];
             // 查询不使用任务执行槽；只有写入运行时共用市场/插件目录时才等待独占保护。
-            if (request.mode === "update") {
+            if (request.type === "marketplace:maintenance" || request.mode === "update") {
                 while (!stopped && now() < deadline && lease === null) {
                     lease = await deps.acquire();
                     if (!lease)
                         await wait();
                 }
                 if (!lease || stopped) {
-                    operations.set(id, { operationId: id, status: "failed", results: [], errorCode: "runtime_busy" });
+                    operations.set(id, { ...operations.get(id), status: "failed", errorCode: "runtime_busy" });
                     return;
                 }
             }
             if (stopped || now() >= deadline)
                 throw new Error("operation_deadline");
-            operations.set(id, { operationId: id, status: "running", results: [], errorCode: null });
+            operations.set(id, { ...operations.get(id), status: "running" });
+            if (request.type === "marketplace:maintenance") {
+                if (!deps.maintain)
+                    throw new Error("maintenance_unavailable");
+                const result = MaintenanceReportSchema.parse(await deps.maintain(request));
+                if (result.operationId !== id)
+                    throw new Error("operation_mismatch");
+                operations.set(id, result);
+                return;
+            }
             const results = [];
             for (const scope of scopes) {
                 if (stopped || now() >= deadline)
@@ -41,7 +51,9 @@ export function createMarketplaceController(deps) {
         }
         catch {
             const previous = operations.get(id);
-            operations.set(id, { ...previous, status: previous.results.some(x => !x.errorCode) ? "partial" : "failed", errorCode: "execution_failed" });
+            operations.set(id, request.type === "marketplace:maintenance"
+                ? { ...previous, status: "unknown", errorCode: "operation_unknown" }
+                : { ...previous, status: previous.results.some(x => !x.errorCode) ? "partial" : "failed", errorCode: "execution_failed" });
         }
         finally {
             try {
@@ -55,22 +67,23 @@ export function createMarketplaceController(deps) {
     };
     return {
         handle(raw) {
-            const parsed = MarketplaceRequestSchema.safeParse(raw);
+            const parsed = MarketplaceRequestSchema.or(MaintenanceRequestSchema).safeParse(raw);
             if (!parsed.success || stopped)
                 return { ok: false, error: "invalid_request" };
             const request = parsed.data;
+            const version = request.type === "marketplace:maintenance" ? { version: 2 } : {};
             const existing = operations.get(request.operationId);
             if (existing)
                 return { ok: true, data: existing };
             if (request.action === "status")
-                return { ok: true, data: { operationId: request.operationId, status: "unknown", results: [], errorCode: "operation_unknown" } };
+                return { ok: true, data: { ...version, operationId: request.operationId, status: "unknown", results: [], errorCode: "operation_unknown" } };
             if (process.platform !== "darwin" && process.platform !== "linux")
                 return { ok: false, error: "unsupported_platform" };
             if (current !== null || [...operations.values()].some(x => marketplaceActive(x.status)))
                 return { ok: false, error: "runtime_busy" };
             if (operations.size >= 100)
                 operations.delete(operations.keys().next().value);
-            const accepted = { operationId: request.operationId, status: "queued", results: [], errorCode: null };
+            const accepted = { ...version, operationId: request.operationId, status: "queued", results: [], errorCode: null };
             operations.set(request.operationId, accepted);
             current = execute(request).finally(() => { current = null; });
             return { ok: true, data: accepted };

package/dist/marketplace-maintenance-bridge.js

@@ -0,0 +1,79 @@
+import { createHash } from "node:crypto";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+import { augmentedPath } from "./runtime-path.js";
+import { MaintenanceReportSchema } from "./marketplace-maintenance-protocol.js";
+export function maintenanceEnvironment(env) {
+    // Keep the machine user's login/config, never forward control-plane credentials.
+    return Object.fromEntries(Object.entries(env).filter(([key]) => !/^(CREW_|NOWCREW_|NOWWORK_)/i.test(key)));
+}
+async function supervise(file, id, cwd, env) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [file, "--run", id], { cwd, env, detached: true, stdio: "ignore" });
+        let expired = false;
+        const kill = () => { if (child.pid) {
+            try {
+                process.kill(-child.pid, "SIGKILL");
+            }
+            catch { /* already gone */ }
+        } };
+        const timer = setTimeout(() => { expired = true; kill(); }, 18 * 60_000);
+        child.once("error", () => { clearTimeout(timer); kill(); reject(new Error("worker_failed")); });
+        child.once("close", code => {
+            clearTimeout(timer);
+            // Never release the machine lock while descendants can still write shared configuration.
+            kill();
+            if (expired || code !== 0)
+                reject(new Error("worker_failed"));
+            else
+                resolve();
+        });
+    });
+}
+export async function runMaintenanceBridge(config, request, acquireEnv) {
+    const fail = (errorCode) => ({ version: 2, operationId: request.operationId, status: "failed", results: [], errorCode });
+    let dir;
+    let started = false;
+    try {
+        const response = await fetch(`${config.serverUrl.replace(/\/+$/, "")}/machine/marketplace-maintenance/${request.operationId}/runner/${request.plan.runner.releaseId}`, {
+            headers: { authorization: `Bearer ${config.machineToken}` }, redirect: "error", signal: AbortSignal.timeout(15_000),
+        });
+        if (!response.ok)
+            return fail("runner_unavailable");
+        // Bound even a malformed server response before buffering or executing it.
+        if (!response.body)
+            return fail("runner_unavailable");
+        const chunks = [];
+        let bytes = 0;
+        for await (const chunk of response.body) {
+            bytes += chunk.length;
+            if (bytes > 256_000)
+                return fail("runner_unavailable");
+            chunks.push(chunk);
+        }
+        const content = Buffer.concat(chunks);
+        if (createHash("sha256").update(content).digest("hex") !== request.plan.runner.sha256)
+            return fail("runner_unavailable");
+        const env = maintenanceEnvironment(await acquireEnv());
+        env.PATH = augmentedPath(env, {}, process.platform, "append");
+        dir = await mkdtemp(join(tmpdir(), "nowwork-maintenance-"));
+        const file = join(dir, "runner.mjs");
+        await writeFile(file, content, { mode: 0o600 });
+        started = true;
+        await supervise(file, request.operationId, dir, env);
+        const report = MaintenanceReportSchema.parse(JSON.parse(await readFile(join(dir, "report.json"), "utf8")));
+        if (report.operationId !== request.operationId)
+            throw new Error("operation_mismatch");
+        return report;
+    }
+    catch {
+        // A killed worker may have changed files: require readback/manual confirmation before another write.
+        return started ? { ...fail("operation_unknown"), status: "unknown" } : fail("runner_unavailable");
+    }
+    finally {
+        if (dir)
+            await rm(dir, { recursive: true, force: true });
+    }
+}

package/dist/marketplace-maintenance-protocol.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+// 与 daemon 同名文件逐字一致；这是独立于旧单插件协议的版本化契约。
+export const MAINTENANCE_CAPABILITY = "marketplace_codex_maintenance_v1";
+export const MaintenancePlanSchema = z.object({
+    marketplace: z.literal("nowwork-pm"),
+    actions: z.tuple([z.literal("install-missing"), z.literal("update-installed")]),
+    hosts: z.tuple([z.literal("claude"), z.literal("codex"), z.literal("pi")]),
+    runner: z.object({ releaseId: z.string().regex(/^[a-f0-9]{64}$/), sha256: z.string().regex(/^[a-f0-9]{64}$/) }).strict(),
+}).strict();
+export const MaintenanceRequestSchema = z.discriminatedUnion("action", [
+    z.object({ type: z.literal("marketplace:maintenance"), action: z.literal("start"), operationId: z.string().uuid(), plan: MaintenancePlanSchema }).strict(),
+    z.object({ type: z.literal("marketplace:maintenance"), action: z.literal("status"), operationId: z.string().uuid() }).strict(),
+]);
+export const MaintenanceErrorSchema = z.enum(["runtime_busy", "execution_failed", "operation_unknown", "runner_unavailable",
+    "manager_missing", "cli_missing", "command_failed", "verification_failed", "source_conflict", "unsupported_platform"]);
+const Version = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._+-]{0,79}$/).nullable();
+export const MaintenanceResultSchema = z.object({
+    runtime: z.enum(["claude", "codex", "pi"]), plugin: z.string().regex(/^[a-z0-9][a-z0-9_-]{0,127}$/).nullable(),
+    status: z.enum(["installed", "updated", "unchanged", "empty", "missing_cli", "failed"]),
+    beforeVersion: Version, afterVersion: Version, targetVersion: Version,
+    activation: z.enum(["reload_required", "not_changed", "unverified"]), errorCode: MaintenanceErrorSchema.nullable(),
+}).strict();
+export const MaintenanceReportSchema = z.object({
+    version: z.literal(2), operationId: z.string().uuid(),
+    status: z.enum(["queued", "running", "completed", "partial", "failed", "unknown"]),
+    results: z.array(MaintenanceResultSchema).max(1500), errorCode: MaintenanceErrorSchema.nullable(),
+}).strict().superRefine((r, ctx) => {
+    const keys = r.results.map(x => `${x.runtime}:${x.plugin}`);
+    if (new Set(keys).size !== keys.length)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "Duplicate plugin result" });
+    for (const x of r.results) {
+        if (["installed", "updated", "unchanged"].includes(x.status) && (!x.plugin || !x.targetVersion || x.targetVersion !== x.afterVersion || x.errorCode)) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: "Successful plugin result requires a verified target version" });
+        }
+    }
+    if (r.status === "completed" && (r.errorCode || ["claude", "codex", "pi"].some(host => !r.results.some(x => x.runtime === host))
+        || r.results.some(x => x.errorCode || x.status === "failed" || x.status === "missing_cli"))) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "Completion requires verified coverage of every host" });
+    }
+});

package/dist/marketplace-protocol.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 // 与另一个进程中的 marketplace-protocol.ts 保持一致；跨进程契约测试校验摘要。
 export const MARKETPLACE_CAPABILITY = "marketplace_update_v1";
 export const MARKETPLACE = "nowwork-pm";
-export const PLUGIN = "aiinterview-plugin";
+export const PLUGIN = "AIinterview-plugin";
 export const MarketplaceModeSchema = z.enum(["inspect", "refresh", "update"]);
 export const MarketplaceStatusSchema = z.enum(["queued", "running", "completed", "partial", "failed", "unknown"]);
 export const MarketplaceTargetSchema = z.object({

package/dist/marketplace-remote.js

@@ -10,7 +10,7 @@ const Target = z.object({
     version: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._+-]{0,79}$/),
     source: z.object({ source: z.literal("git-subdir"),
         url: z.literal("git@codeup.aliyun.com:6128d2e757e7cd986dfae5ab/pm/AIinterview-agent-skill.git"),
-        path: z.literal("plugins/aiinterview-plugin"), sha: z.string().regex(/^[a-f0-9]{40}$/) }),
+        path: z.literal("plugins/AIinterview-plugin"), sha: z.string().regex(/^[a-f0-9]{40}$/) }),
 });
 export async function readRemoteMarketplace(runtime, registered, env, command) {
     const source = validateMarketplaceSource(registered.url, registered.ref);

package/dist/marketplace-runner.js

@@ -12,7 +12,7 @@ import { readMarketplaceSource } from "./marketplace-source.js";
 export { MarketplaceFailure, runMarketplaceCommand } from "./marketplace-command.js";
 const SELECTOR = `${PLUGIN}@${MARKETPLACE}`;
 const SOURCE = "git@codeup.aliyun.com:6128d2e757e7cd986dfae5ab/pm/AIinterview-agent-skill.git";
-const SOURCE_PATH = "plugins/aiinterview-plugin";
+const SOURCE_PATH = "plugins/AIinterview-plugin";
 const obj = (x) => x !== null && typeof x === "object" && !Array.isArray(x) ? x : {};
 const parse = (text) => { try {
     return JSON.parse(text);

package/dist/marketplace-serve.js

@@ -1,7 +1,9 @@
+import { runMaintenanceBridge } from "./marketplace-maintenance-bridge.js";
 import { createMarketplaceController } from "./marketplace-controller.js";
 import { prepareDaemonRestart } from "./daemon-updater.js";
-export function createServeMarketplace(config, localSlots, hostCoordinator) {
+export function createServeMarketplace(config, localSlots, hostCoordinator, acquireEnv = async () => ({ ...process.env })) {
     const controller = createMarketplaceController({ agentsRoot: config.agentsRoot,
+        maintain: request => runMaintenanceBridge(config, request, acquireEnv),
         acquire: async () => {
             // Marketplace updates can mutate shared Codex/Claude homes across profiles.
             const local = await prepareDaemonRestart({ localSlots });
@@ -29,7 +31,7 @@ export function createServeMarketplace(config, localSlots, hostCoordinator) {
         } });
     return {
         handle(raw, send) {
-            if (!raw || typeof raw !== "object" || !("type" in raw) || raw.type !== "marketplace:operation")
+            if (!raw || typeof raw !== "object" || !("type" in raw) || (raw.type !== "marketplace:operation" && raw.type !== "marketplace:maintenance"))
                 return false;
             const { reqId, ...request } = raw;
             if (typeof reqId === "string")

package/dist/memory-prune-diagnostics.js

@@ -7,7 +7,6 @@ import { dslog } from "./slog.js";
 const TRACE_PATTERN = /\[memory-prune trace_id=([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\]/i;
 export const MEMORY_PRUNE_HASH_LIMIT_BYTES = 10 * 1024 * 1024;
 export const MEMORY_PRUNE_NOTES_MANIFEST_LIMIT = 128;
-export const MEMORY_PRUNE_PENDING_MANIFEST_LIMIT = 128;
 export const MEMORY_PRUNE_NOTE_CHANGE_LIMIT = 128;
 function compareCodeUnits(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
@@ -193,50 +192,6 @@ export async function inspectMemoryPruneNotes(homeDir, signal) {
         ...(signal?.aborted ? { error: "ABORT_ERR" } : {}),
     };
 }
-export async function inspectMemoryPrunePending(homeDir, signal) {
-    const pendingDir = join(homeDir, ".crew", "memory", "pending");
-    try {
-        const metadata = await lstat(pendingDir);
-        if (metadata.isSymbolicLink())
-            return { files: [], total_count: 0, omitted_count: 0, truncated: false, error: "symbolic_link" };
-        if (!metadata.isDirectory())
-            return { files: [], total_count: 0, omitted_count: 0, truncated: false, error: "ENOTDIR" };
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return { files: [], total_count: 0, omitted_count: 0, truncated: false };
-        return { files: [], total_count: 0, omitted_count: 0, truncated: false, error: diagnosticError(error) };
-    }
-    let names;
-    try {
-        names = (await readdir(pendingDir, { withFileTypes: true }))
-            .filter(entry => (entry.isFile() || entry.isSymbolicLink()) && entry.name.endsWith(".json"))
-            .map(entry => entry.name).sort(compareCodeUnits);
-    }
-    catch (error) {
-        return { files: [], total_count: 0, omitted_count: 0, truncated: false, error: diagnosticError(error) };
-    }
-    const selected = names.slice(0, MEMORY_PRUNE_PENDING_MANIFEST_LIMIT);
-    const files = [];
-    for (const name of selected) {
-        if (signal?.aborted)
-            break;
-        const path = join(pendingDir, name);
-        try {
-            if ((await lstat(path)).isSymbolicLink()) {
-                files.push({ relative_path: `.crew/memory/pending/${name}`, exists: false, error: "symbolic_link" });
-                continue;
-            }
-        }
-        catch (error) {
-            files.push({ relative_path: `.crew/memory/pending/${name}`, exists: false, error: diagnosticError(error) });
-            continue;
-        }
-        files.push({ relative_path: `.crew/memory/pending/${name}`, ...await inspectFile(path, false, undefined, signal) });
-    }
-    return { files, total_count: names.length, omitted_count: Math.max(0, names.length - selected.length),
-        truncated: names.length > selected.length, ...(signal?.aborted ? { error: "ABORT_ERR" } : {}) };
-}
 async function inspectMemoryPruneFixedFiles(homeDir, runDir, workLogPath, signal) {
     const cwdIsHome = runDir === homeDir;
     const [memory, lessons, cwdMemory, cwdLessons, workLog] = await Promise.all([
@@ -255,17 +210,15 @@ async function inspectMemoryPruneFixedFiles(homeDir, runDir, workLogPath, signal
     };
 }
 export async function inspectMemoryPruneFiles(homeDir, runDir, workLogPath, signal) {
-    const [fixedFiles, notesManifest, pendingManifest] = await Promise.all([
+    const [fixedFiles, notesManifest] = await Promise.all([
         inspectMemoryPruneFixedFiles(homeDir, runDir, workLogPath, signal),
         inspectMemoryPruneNotes(homeDir, signal),
-        inspectMemoryPrunePending(homeDir, signal),
     ]);
-    return { ...fixedFiles, notes_manifest: notesManifest, pending_manifest: pendingManifest };
+    return { ...fixedFiles, notes_manifest: notesManifest };
 }
 export async function inspectMemoryPruneFilesWithinDeadline(homeDir, runDir, workLogPath, timeoutMs) {
     const fixedFiles = await withinMemoryPruneDiagnosticsDeadline((signal) => inspectMemoryPruneFixedFiles(homeDir, runDir, workLogPath, signal), timeoutMs);
     let notesManifest;
-    let pendingManifest;
     try {
         notesManifest = await withinMemoryPruneDiagnosticsDeadline((signal) => inspectMemoryPruneNotes(homeDir, signal), timeoutMs);
     }
@@ -278,13 +231,7 @@ export async function inspectMemoryPruneFilesWithinDeadline(homeDir, runDir, wor
             error: diagnosticError(error),
         };
     }
-    try {
-        pendingManifest = await withinMemoryPruneDiagnosticsDeadline(signal => inspectMemoryPrunePending(homeDir, signal), timeoutMs);
-    }
-    catch (error) {
-        pendingManifest = { files: [], total_count: 0, omitted_count: 0, truncated: false, error: diagnosticError(error) };
-    }
-    return { ...fixedFiles, notes_manifest: notesManifest, pending_manifest: pendingManifest };
+    return { ...fixedFiles, notes_manifest: notesManifest };
 }
 export async function withinMemoryPruneDiagnosticsDeadline(operation, timeoutMs) {
     const controller = new AbortController();
@@ -414,7 +361,6 @@ export function evaluateMemoryPrunePostcondition(before, after, execution) {
             && (after.cwd_memory.lessons_reference_count ?? 0) > 0,
         cwd_lessons_changed: !after.cwd_lessons.same_as_shared_path
             && fileChanged(before.cwd_lessons, after.cwd_lessons),
-        pending_changed: diffMemoryPruneNotes(before.pending_manifest ?? { files: [], total_count: 0, omitted_count: 0, truncated: false }, after.pending_manifest ?? { files: [], total_count: 0, omitted_count: 0, truncated: false }).change_count > 0,
     };
     let outcome;
     if (!execution.executorCompleted)
@@ -442,8 +388,6 @@ export function evaluateMemoryPrunePostcondition(before, after, execution) {
         outcome = "promoted_without_index_change";
     else if (facts.shared_memory_changed)
         outcome = "shared_memory_updated";
-    else if (facts.pending_changed)
-        outcome = "pending_updated";
     else
         outcome = "no_files_changed";
     return { outcome, ...facts };
@@ -464,7 +408,7 @@ function memoryPruneFileFactFields(fileFacts) {
     }
     return fields;
 }
-export function memoryPruneSnapshotFields({ notes_manifest: _notesManifest, pending_manifest: _pendingManifest, ...fileFacts }) {
+export function memoryPruneSnapshotFields({ notes_manifest: _notesManifest, ...fileFacts }) {
     return memoryPruneFileFactFields(fileFacts);
 }
 export function logMemoryPruneDiagnosticsFailure(input, traceId, phase, error) {

package/dist/message-file-preview.js

@@ -9,7 +9,6 @@ import { z } from "zod";
 import { isInternalEnvironmentPath } from "./workspace-fs.js";
 import { opaqueKey, safeKey } from "./workspace.js";
 import { AgentHandleSchema } from "./execution-protocol.js";
-import { withMemoryAccess } from "./local-memory/migration-access.js";
 const MAX_BYTES = 256 * 1024;
 const MAX_BINARY_BYTES = 8 * 1024 * 1024;
 const MAX_CONCURRENT_READS = 4;
@@ -232,16 +231,7 @@ export async function readSharedMessageFile(agentsRoot, rawRequest, registry) {
         throw new SharedFileError("file_preview_busy");
     activeReads++;
     try {
-        const candidate = await resolveCandidate(agentsRoot, parsed.data, registry);
-        const agentRoot = await realpath(resolve(agentsRoot, parsed.data.handle)).catch((error) => {
-            if (error.code === "ENOENT")
-                return undefined;
-            throw error;
-        });
-        // 记忆保护只用于该Agent根内资料，独立项目文件仍按原执行授权读取。
-        return await (agentRoot && inside(agentRoot, candidate.path)
-            ? withMemoryAccess(agentRoot, () => readCandidate(candidate))
-            : readCandidate(candidate));
+        return await readCandidate(await resolveCandidate(agentsRoot, parsed.data, registry));
     }
     catch (error) {
         if (error instanceof SharedFileError)

package/dist/npm-command.js

@@ -1,9 +1,9 @@
 import { posix, win32 } from "node:path";
-/** Execute npm through its owning Node binary so PATH and cmd.exe quoting are irrelevant. */
+/** Execute POSIX npm through its owning Node binary so service PATH is irrelevant. */
 export function npmInvocation(platform, nodePath = process.execPath) {
     const paths = platform === "win32" ? win32 : posix;
-    const npmPath = platform === "win32"
-        ? paths.join(paths.dirname(nodePath), "node_modules", "npm", "bin", "npm-cli.js")
-        : paths.join(paths.dirname(nodePath), "npm");
-    return { command: nodePath, argsPrefix: [npmPath] };
+    const npmPath = paths.join(paths.dirname(nodePath), platform === "win32" ? "npm.cmd" : "npm");
+    return platform === "win32"
+        ? { command: npmPath, argsPrefix: [] }
+        : { command: nodePath, argsPrefix: [npmPath] };
 }

package/dist/project-skills/machine-hello-publisher.js

@@ -1,109 +1,20 @@
 import { WebSocket } from "ws";
-const HELLO_RETRY_DELAYS_MS = [1_000, 2_000, 4_000];
 /** 记住最近一次 hello 与 socket,便于存储身份变化后重发;Project Skills 状态恒为 ready。 */
 export function createMachineHelloPublisher(input) {
     let latest = null;
     let latestSocket = null;
-    let acknowledged = false;
-    let attempts = 0;
-    // 发送代次:每开一轮新发送(attach/publish/republish)自增,随帧发出并要求 ack 回显。
-    let generation = 0;
-    let retryTimer;
-    const clearRetry = () => {
-        if (retryTimer !== undefined) {
-            clearTimeout(retryTimer);
-            retryTimer = undefined;
-        }
-    };
-    const scheduleRetry = () => {
-        clearRetry();
-        if (acknowledged || latest === null || latestSocket?.readyState !== WebSocket.OPEN)
-            return;
-        // 当前 server 不支持 ack → 不排重试(否则永远等不到确认,白跑满退避)。
-        if (input.ackSupported && !input.ackSupported())
-            return;
-        const delay = HELLO_RETRY_DELAYS_MS[attempts - 1];
-        if (delay === undefined) {
-            // 退避跑满仍未 ack:期待 ack(ackSupported 已声明支持)才升级为断连重连,避免旧行为下反复重连。
-            if (input.ackSupported !== undefined && latestSocket !== null)
-                input.onExhausted?.(latestSocket);
-            return;
-        }
-        retryTimer = setTimeout(() => {
-            retryTimer = undefined;
-            sendCurrent();
-        }, delay);
-    };
-    function sendCurrent() {
-        if (latest === null || latestSocket?.readyState !== WebSocket.OPEN || acknowledged)
+    const republish = () => {
+        if (latest === null || latestSocket?.readyState !== WebSocket.OPEN)
             return;
-        // helloSeq 随帧发出;同一代次的多次重试复用同一 seq,ack 回显该 seq 即视为确认。
-        const hello = input.effective({ ...latest, projectSkillsStatus: "ready", helloSeq: generation });
-        const attempt = attempts + 1;
-        attempts = attempt;
+        const hello = input.effective({ ...latest, projectSkillsStatus: "ready" });
         try {
             latestSocket.send(JSON.stringify(hello));
-            input.onSent(hello, attempt);
-        }
-        catch (error) {
-            input.onSendFailed?.(hello, attempt, error);
+            input.onSent(hello);
         }
-        scheduleRetry();
-    }
-    const attach = (socket) => {
-        clearRetry();
-        latestSocket = socket;
-        acknowledged = false;
-        attempts = 0;
-        generation += 1;
-        sendCurrent();
-    };
-    const detach = (socket) => {
-        if (latestSocket !== socket)
-            return;
-        clearRetry();
-        latestSocket = null;
-        acknowledged = false;
-        attempts = 0;
-    };
-    const republish = () => {
-        if (latest === null || latestSocket === null)
-            return;
-        clearRetry();
-        acknowledged = false;
-        attempts = 0;
-        generation += 1;
-        sendCurrent();
-    };
-    const acknowledge = (socket, seq) => {
-        // 非当前 socket / 已确认 / 该 socket 已在关闭(close 后迟到的 ack)一律忽略:
-        // 后者会错误触发 onAck→清零强制重连计数,削弱重连上限。
-        if (latestSocket !== socket || latest === null || acknowledged || socket.readyState !== WebSocket.OPEN)
-            return;
-        // 代次校验:只接受回显当前代次的 ack,忽略上一代次迟到的 ack(否则会误停新代次的重试)。
-        // seq 缺省(老 server 不回显)时退回仅按 socket 匹配,保持兼容。
-        if (seq !== undefined && seq !== generation)
-            return;
-        acknowledged = true;
-        clearRetry();
-        input.onAck?.(input.effective({ ...latest, projectSkillsStatus: "ready" }));
+        catch { /* 非 OPEN,忽略 */ }
     };
     return Object.freeze({
-        publish: (hello, socket) => {
-            latest = hello;
-            if (latestSocket !== socket) {
-                attach(socket);
-                return;
-            }
-            acknowledged = false;
-            attempts = 0;
-            generation += 1;
-            clearRetry();
-            sendCurrent();
-        },
-        attach,
-        detach,
+        publish: (hello, socket) => { latest = hello; latestSocket = socket; republish(); },
         republish,
-        acknowledge,
     });
 }

package/dist/prompt.js

@@ -5,7 +5,6 @@
  * claim-before-work、freshness/draft、"做完所有事再停"、inbox notice 语义、
  * 分层记忆与压缩安全、协作礼仪。措辞为本项目原创。
  */
-import { detectLocalMemoryStorageVersion, selectLocalMemoryPreview } from "./local-memory/storage-format.js";
 /** work-log 注入上限(字符):防冷启动注入随文件膨胀。超限保头(目标/结论)+尾(最近进展),
  *  截中段并提示读全文——全文仍在盘上,只限"默认推送量"不限"可获取量"。纯函数。 */
 export const WORKLOG_INJECT_CAP = 8000;
@@ -68,10 +67,7 @@ export function capWorkLogForInject(workLog, cap = WORKLOG_INJECT_CAP) {
     const tail = workLog.slice(-WORKLOG_TAIL);
     return `${head}\n…(work-log 过长已截去中段,全文用 Read 读 $CREW_TASK_LOG)\n${tail}`;
 }
-export function capMemoryForInject(memory, cap = MEMORY_INJECT_CAP, maxBytes = Number.POSITIVE_INFINITY, query = "") {
-    if (detectLocalMemoryStorageVersion(memory) === 2) {
-        return selectLocalMemoryPreview(memory, query, { maxCodePoints: cap, maxBytes }).memory;
-    }
+export function capMemoryForInject(memory, cap = MEMORY_INJECT_CAP, maxBytes = Number.POSITIVE_INFINITY) {
     if (memory.length <= cap && Buffer.byteLength(memory, "utf8") <= maxBytes)
         return memory;
     const notice = "[MEMORY.md preview truncated; use crew-memory search/read for more.]\n";
@@ -346,7 +342,7 @@ ${interactiveTaskRules}${freshnessRule}${externalReplyRule}${collaborationEtique
 
 ## Workspace 与分层记忆(CRITICAL — 索引+按需,配合上面的并行规则)
 你的持久记忆在 \`$CREW_HOME\`(跨你所有任务共享),按“常驻索引 + 功能明细 + 当前工作”分层:
-1. **MEMORY.md = 常驻索引 + 角色**:提示词末尾可能只有它的有界预览,预算不足时也可能省略。预览未命中不等于没有记忆。旧版索引可能包含 \`scope\`；V2 规范字段为 \`id/file/type/status/summary/triggers/priority/revision/anchor/updated\`(可选 \`review_after\`),不含 \`scope\`。其中 file 是相对于 \`$CREW_HOME\` 的路径(例如 \`notes/testing.md\`);需要历史约束、经验或偏好时先检索完整索引,再按需分段读取。
+1. **MEMORY.md = 常驻索引 + 角色**:提示词末尾可能只有它的有界预览,预算不足时也可能省略。预览未命中不等于没有记忆。索引条目包含 \`file/type/scope/summary/triggers/priority/updated\`,其中 file 是相对于 \`$CREW_HOME\` 的路径(例如 \`notes/testing.md\`);需要历史约束、经验或偏好时先检索完整索引,再按需分段读取。
 2. **notes/<topic>.md = 功能明细**:按用户偏好、项目规则、测试、调试、Git、事故复盘等主题拆分。优先读取与当前任务匹配的文件;\`notes/lessons.md\` 只保留未分类经验和历史兼容内容,不是所有新经验的默认目的地。普通任务默认只读不写,但当前用户明确要求时可以按最小范围更新;任务结束后的专门收尾执行仍按收尾指令复核。
    - 对旧版 MEMORY.md,如果条目没有完整结构化字段但明确指向 \`notes/<file>.md\`,把它视为 legacy 索引;仍需结合条目标题/链接和当前请求判断相关性,不要因为缺少 summary/triggers 就假定正文已注入。
 3. **本任务 work-log = \`$CREW_TASK_LOG\`**:每任务一份(别的运行不会碰),记当前阶段/下一步/卡点/关键结论。系统已把它的当前内容注入末尾让你续上;有进展就更新它——这是你**唯一**该在任务中持续写的记忆文件。**work-log 是现状快照,不是流水账**:保持 ≤100 行,更新时重写全文替换过时内容,不要无限追加(过长会被注入截断)。

package/dist/runner.js

@@ -80,7 +80,7 @@ async function runAgentWithMachineEnvironment(config, input, onActivity = defaul
                 ? { scheduledExternalNotificationPolicy: input.scheduled.externalNotificationPolicy }
                 : {}),
             ...(input.wakeOrigin ? { wakeOrigin: input.wakeOrigin } : {}),
-            memory: capMemoryForInject(workspace.memory, undefined, undefined, baseWake),
+            memory: capMemoryForInject(workspace.memory),
             ...(resuming ? {} : { workLog: capWorkLogForInject(workspace.workLog) }),
             collaborationToolsEnabled: config.codexCollaborationTools && runtime === "codex",
             localMemoryV2Enabled: workspace.localMemoryV2Enabled ?? localMemoryV2Enabled,

package/dist/runtimes/claude-thread-runner.js

@@ -12,14 +12,6 @@ const InputSchema = z.object({ bin: z.string().min(1), args: z.array(z.string())
     wakePrompt: z.string().min(1), sessionId: z.string().min(1).optional(), resume: z.boolean() }).strict();
 class PreflightError extends Error {
 }
-// Claude waits for every merged SessionStart hook before acknowledging SDK
-// initialization. Those hooks may legitimately outlive the old 30s adapter
-// deadline. Cap this phase below the daemon's default 120s fail-closed startup
-// window so wrapper failure propagation and supervisor-owned tree cleanup retain
-// margin. The 100s cap leaves a nominal 20s outside this phase; this runner's
-// local TERM/KILL cleanup is itself bounded to 2s.
-// Resume and cold recovery share this one budget; hook activity never extends it.
-export const CLAUDE_INITIALIZE_TIMEOUT_MS = 100_000;
 function hookCommand(path, nonce) {
     const source = import.meta.url.endsWith(".ts");
     const hook = fileURLToPath(new URL(`./claude-session-start-hook.${source ? "ts" : "js"}`, import.meta.url));
@@ -60,9 +52,6 @@ async function bounded(promise, milliseconds, label) {
         clearTimeout(timer);
     }
 }
-export function waitForClaudeInitialize(initialized, timeoutMs = CLAUDE_INITIALIZE_TIMEOUT_MS) {
-    return bounded(initialized, timeoutMs, "claude_initialize_timeout");
-}
 async function attempt(input, sessionId, resume, options) {
     const proofDir = await mkdtemp(join(tmpdir(), "nowwork-claude-session-"));
     const proofPath = join(proofDir, "proof.json");
@@ -199,7 +188,7 @@ async function attempt(input, sessionId, resume, options) {
     try {
         try {
             await send({ type: "control_request", request_id: initId, request: { subtype: "initialize" } });
-            await waitForClaudeInitialize(initialized.promise, options.initializeTimeoutMs);
+            await bounded(initialized.promise, options.initializeTimeoutMs ?? 30_000, "claude_initialize_timeout");
             const proof = JSON.parse(await readFile(proofPath, "utf8"));
             if (proof.nonce !== nonce || proof.sessionId !== sessionId || proof.source !== (resume ? "resume" : "startup")) {
                 throw new Error("claude_session_proof_mismatch");
@@ -249,25 +238,15 @@ async function attempt(input, sessionId, resume, options) {
 }
 export async function runClaudeThread(input, options = {}) {
     const sessionId = input.sessionId ?? randomUUID();
-    const initializeBudgetMs = options.initializeTimeoutMs ?? CLAUDE_INITIALIZE_TIMEOUT_MS;
-    const now = options.now ?? (() => performance.now());
-    const initializeDeadline = now() + Math.max(0, initializeBudgetMs);
-    const runAttempt = (attemptSessionId, resume) => {
-        const remainingMs = Math.max(0, Math.ceil(initializeDeadline - now()));
-        if (remainingMs === 0)
-            return Promise.reject(new PreflightError("claude_native_session_unconfirmed"));
-        return attempt(input, attemptSessionId, resume, { ...options, initializeTimeoutMs: remainingMs });
-    };
     try {
-        return await runAttempt(sessionId, input.resume);
+        return await attempt(input, sessionId, input.resume, options);
     }
     catch (error) {
         // The failed attempt never received a business user turn or entered its
-        // model/tool loop. Native startup hooks may run again on cold recovery,
-        // within the original aggregate initialize deadline.
+        // model/tool loop. Native startup hooks may run again on cold recovery.
         if (!input.resume || !(error instanceof PreflightError || error instanceof ThreadDeliveryColdStartRequired))
             throw error;
-        return runAttempt(randomUUID(), false);
+        return attempt(input, randomUUID(), false, options);
     }
 }
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {