@nowcrew/daemon 0.6.88-beta.8 → 0.6.88

package/README.md

@@ -242,26 +242,26 @@ The stable adapters keep prompts out of provider argv wherever the provider prot
 
 | Runtime | Transport | System/wake input | Native resume |
 | --- | --- | --- | --- |
-| Claude | stream-json CLI | daemon-owned system prompt file | CLI session id |
-| Codex | app-server JSON-RPC over stdio | `developerInstructions` + turn input | `thread/resume` |
-| Kimi | ACP over stdio | `session/prompt` | `session/resume` (`session/load` compatibility fallback) |
-| Hermes | ACP over stdio | `session/prompt` | `session/resume` (`session/load` compatibility fallback) |
-| OpenCode | `run --format json` | stdin | `--session` |
+| Claude | stream-json CLI | daemon-owned system prompt file + user input | CLI session id; thread-bound: matching native SessionStart proof + SDK initialization |
+| Codex | app-server JSON-RPC over stdio | `developerInstructions` + turn input | `thread/resume`; thread-bound: returned id must match |
+| Kimi | ACP over stdio | `session/prompt` | unbound: `session/resume` (`session/load` fallback); thread-bound: cold |
+| Hermes | ACP over stdio | `session/prompt` | unbound: `session/resume` (`session/load` fallback); thread-bound: cold |
+| OpenCode | `run --format json` | stdin | unbound: `--session`; thread-bound: cold |
 | DeepSeek Harness | ACP over stdio | `session/prompt` | none (fresh session per execution) |
 
 Kimi ACP currently requires a Kimi account even when the CLI has a working custom provider. Only for
 the explicit `Authentication required` response, the adapter retries once through Kimi's stream-json
-CLI and carries the same native session id; unrelated ACP failures stay failures. The CLI fallback is
+CLI; only unbound executions can carry a saved native session id. Unrelated ACP failures stay failures. The CLI fallback is
 subject to the Windows UTF-16 argv guard, while protocol-v1 itself remains disabled on Windows until
 durable Job Object ownership is available.
 
 Hermes uses only ACP capabilities advertised by the installed CLI. Model and effort choices come from
 a short-lived discovery session; credentials, provider profiles, plugins, and `HERMES_HOME` remain
-machine-local. A missing resumed ACP session is retried once as a fresh session.
+machine-local. For unbound executions, a missing resumed ACP session is retried once as a fresh session.
 
 OpenCode receives the prompt through stdin and runs with both cwd and `PWD` anchored to the Agent
 workspace. Models and variants come from `opencode models --verbose` (with the plain catalog as a
-compatibility fallback). A missing resumed session is retried once without `--session`; malformed,
+compatibility fallback). For unbound executions, a missing resumed session is retried once without `--session`; malformed,
 empty, incomplete, or explicitly failed JSON streams remain failures. NowWork never writes
 `opencode.json` or replaces `OPENCODE_CONFIG_CONTENT`. The daemon advertises OpenCode as executable
 only when `opencode run --help` exposes `--format`, `--dangerously-skip-permissions`, `--dir`,
@@ -291,8 +291,12 @@ uses fresh sessions and committed text; it does not claim resume, images, MCP, r
 or transcript support. Agent environment variables cannot override `DEEPSEEK_*`, `DSH_*`, or
 `NOWCREW_DEEPSEEK_HARNESS_CONFIG`; those values always come from the daemon service environment.
 
-Codex, Kimi, Hermes, and OpenCode sessions use the same bounded per-task persistence and keyed lease as Claude when they
-run through protocol v1. A first-progress watchdog covers a provider that accepts a turn but remains
+Unbound Codex, Kimi, Hermes, and OpenCode sessions retain the same configured warm/budget policy and keyed
+lease as Claude through protocol v1. Thread-bound Claude/Codex sessions keep their native session across
+warm-cache expiry, token estimates, and turn counts; verified restoration receives only accepted-cursor
+deltas. New sessions and runtimes without verified restoration receive complete current-thread history
+before the business turn. See the [thread context contract](../docs/thread-scoped-native-context.md).
+A first-progress watchdog covers a provider that accepts a turn but remains
 semantically silent; after the first semantic event, the execution's configured total timeout remains
 authoritative so a legitimate long-running tool is not killed for quiet output.
 DeepSeek Harness is execution-v1-only and intentionally skips native session persistence.

package/dist/agent-memory/policy.js

@@ -17,7 +17,9 @@ function truncateUtf8(value, maxBytes) {
     return output;
 }
 export function extractIncomingMessage(wakePrompt) {
-    const match = wakePrompt.match(/(?:^|\n)(?:Incoming message|来信):[ \t]*(.*?)(?=\n(?:Start with crew|先用 crew)|$)/su);
+    // Keep legacy wake delimiters while accepting program-delivered-context prompts.
+    // Stop before policy/history blocks; neither is the current user's message.
+    const match = wakePrompt.match(/(?:^|\n)(?:Incoming message|来信):[ \t]*(.*?)(?=\n(?:Start with crew|先用 crew|Work directly from this thread's context|直接依据程序交付的本线程上下文|No thread anchor:|没有线程锚点[，,])|$)/su);
     const content = match?.[1]?.trim();
     return content ? content : null;
 }

package/dist/execution-protocol.js

@@ -200,7 +200,7 @@ export const ExecutionStartSchema = z.object({
         language: z.enum(["zh", "en"]),
         systemPrompt: z.string(),
         wakePrompt: z.string(),
-        maintenancePurpose: z.literal("self_training").optional(),
+        maintenancePurpose: z.enum(["self_training", "memory_prune"]).optional(),
     }).strict(),
     runtime: z.object({
         name: RuntimeSchema,

package/dist/execution-runner.js

@@ -844,6 +844,7 @@ export async function runExecution(config, input, dependencies) {
             executionId: spec.executionId,
             handle: spec.agent.handle,
             channelId: spec.context.channelId,
+            ...(spec.context.threadId === undefined ? {} : { threadId: spec.context.threadId }),
             keyMode: "opaque",
             taskKey: spec.workspace.taskKey,
             ...(spec.workspace.resumeKey === undefined ? {} : { resumeKey: spec.workspace.resumeKey }),
@@ -885,13 +886,13 @@ export async function runExecution(config, input, dependencies) {
                 } : {}),
             },
             session: {
-                enabled: selfTraining ? false : config.resume,
+                enabled: spec.instructions.maintenancePurpose !== undefined ? false : config.resume,
                 warmMs: config.resumeWarmMs,
                 budgetTokens: config.sessionBudgetTokens,
                 softTokens: config.sessionSoftTokens,
                 maxTurns: config.sessionMaxTurns,
             },
-            ...(selfTraining ? { maintenancePurpose: "self_training" } : {}),
+            ...(spec.instructions.maintenancePurpose === undefined ? {} : { maintenancePurpose: spec.instructions.maintenancePurpose }),
             localMemoryV2Enabled,
         };
         const result = await Promise.race([

package/dist/local-executor.js

@@ -15,6 +15,8 @@ import { deliverCloudReports, prepareCloudReportExecution } from "./cloud-report
 import { reportDeliveryContext } from "./cloud-report-receipt.js";
 import { extractFinalText, extractRunMeta, normalizeEvent, parseLine, } from "./normalize.js";
 import { readSession, writeSession, pickResumeId, isNearBudget } from "./session.js";
+import { NativeThreadContext, isolateMaintenanceSession } from "./native-thread-context.js";
+import { prepareThreadDelivery } from "./thread-input-delivery.js";
 import { providerErrorFromExit } from "./provider-error.js";
 import { createConsoleFormatter } from "./console-formatter.js";
 import { withLocalExecutionFacts, } from "./local-execution-prompt.js";
@@ -108,6 +110,9 @@ async function launchLegacyRuntime(request) {
     if (request.runtime === "deepseek-harness") {
         throw new Error("DeepSeek Harness requires execution protocol v1");
     }
+    if (request.runtime !== "claude")
+        request = { ...request, wakePrompt: (await prepareThreadDelivery({ env: request.env,
+                resumed: false, sessionId: "unverified-cold-legacy", wakePrompt: request.wakePrompt })).prompt };
     const common = {
         bin: request.bin,
         cwd: request.cwd,
@@ -175,6 +180,7 @@ async function withKeyedLease(key, operation, cancellation) {
     }
 }
 export async function executeLocal(input, callbacks = {}, dependencies = {}) {
+    input = isolateMaintenanceSession(input);
     const versionedProjectSkills = input.projectSkills !== undefined
         && !Array.isArray(input.projectSkills);
     if (versionedProjectSkills && (input.runtime.name !== "codex" && input.runtime.name !== "claude")) {
@@ -255,6 +261,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     let localMemoryResultPath = null;
     let executionWorkspace = workspace;
     let localMemoryTelemetry = null;
+    let nativeThreadContext = null;
     const inheritedEnv = { ...process.env };
     const reportRoots = {
         root: workspace.dir,
@@ -294,12 +301,11 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             : null;
         const currentPrior = storedCurrentPrior !== null
             && storedCurrentPrior.sessionContextFingerprint === input.sessionContextFingerprint
+            && storedCurrentPrior.runtime === runtime.name
+            && storedCurrentPrior.threadRoot === input.resumeKey
             ? storedCurrentPrior
             : null;
-        // Interactive V1 uses collision-resistant session directories, while the
-        // older legacy path stored metadata under tasks/<safe thread key>. Import
-        // that metadata once so an existing thread can cross the protocol boundary
-        // without losing its native runtime conversation.
+        // Import compatible legacy metadata across the protocol boundary.
         const legacyRunDir = input.session.enabled
             && supportsNativeResume
             && input.keyMode === "opaque"
@@ -315,7 +321,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const legacyPrior = legacyRunDir === null || (currentPrior !== null && !legacyCwdPinned)
             ? null
             : await readSession(legacyRunDir);
-        const prior = currentPrior ?? legacyPrior;
+        const compatibleLegacyPrior = legacyPrior?.runtime === runtime.name && legacyPrior?.threadRoot === input.resumeKey
+            ? legacyPrior : null;
+        const prior = currentPrior ?? compatibleLegacyPrior;
         const sessionExists = workspace.sessionResume || legacyPrior !== null;
         const usesLegacyCwd = legacyRunDir !== null
             && (legacyCwdPinned || (currentPrior === null && legacyPrior !== null));
@@ -336,11 +344,11 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             ? prior?.model ?? currentModel
             : currentModel;
         const resumeSessionId = supportsNativeResume && sessionExists
-            ? pickResumeId(prior, Date.now(), input.session.warmMs, resumeComparisonModel, input.session.budgetTokens, input.session.maxTurns, providerFp)
+            ? pickResumeId(input.resumeKey && (!Number.isSafeInteger(prior?.threadContextSeq) || prior?.threadHistoryComplete !== true) ? null : prior, Date.now(), input.resumeKey ? 0 : input.session.warmMs, resumeComparisonModel, input.resumeKey ? 0 : input.session.budgetTokens, input.resumeKey ? 0 : input.session.maxTurns, providerFp)
             : null;
         const resuming = resumeSessionId !== null;
         const rotatedForBudget = !resuming && supportsNativeResume && sessionExists
-            && pickResumeId(prior, Date.now(), input.session.warmMs, resumeComparisonModel, 0, 0, providerFp) !== null;
+            && pickResumeId(prior, Date.now(), input.resumeKey ? 0 : input.session.warmMs, resumeComparisonModel, 0, 0, providerFp) !== null;
         const nearBudget = resuming && isNearBudget(prior, input.session.softTokens);
         const rotated = Boolean(workspace.agentSessionId && sessionExists && !resuming);
         // Codex and Kimi choose their own id on a fresh start, so the native id persisted in
@@ -467,6 +475,11 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         }
         memoryPruneFailurePhase = "runtime_prepare";
         const crewHome = isolatedMaintenance ? executionWorkspace.runDir : workspace.dir;
+        const contextThreadId = input.threadId ?? input.resumeKey;
+        if (contextThreadId && input.maintenancePurpose === undefined) {
+            nativeThreadContext = new NativeThreadContext(join(executionWorkspace.runDir, `.crew-context-${input.executionId}.json`), contextThreadId, runtime.name, resumeSessionId, prior);
+            await nativeThreadContext.initialize();
+        }
         const baseEnv = {
             ...inheritedEnv,
             ...sanitizeEnvVars(providerConfig.envVars),
@@ -479,6 +492,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             CREW_TOKEN: input.launch.token,
             CREW_CHANNEL: input.channelId,
             CREW_HOME: crewHome,
+            // Empty values override any stale inherited hints from an enclosing runtime.
+            CREW_THREAD_ROOT: contextThreadId ?? "",
+            CREW_THREAD_CONTEXT_FILE: nativeThreadContext?.path ?? "",
             // Keep the daemon-selected storage root authoritative for runtimes.
             // In profile-backed NowWork sessions the daemon config may differ from
             // the daemon process environment, so inheriting CREW_AGENTS_ROOT is not
@@ -803,6 +819,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             const event = parseLine(line);
             if (!event)
                 return;
+            nativeThreadContext?.observe(event);
             localMemoryTelemetry?.observe(event);
             if (isRuntimeReadyEvent(runtime.name, event))
                 markRuntimeReady();
@@ -961,9 +978,12 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 ? usage.inputTokens + usage.cacheReadTokens + usage.cacheCreationTokens
                 : (resuming ? prior?.contextTokens : undefined);
             await writeSession(workspace.sessionDir, {
+                runtime: runtime.name,
+                ...(input.resumeKey === undefined ? {} : { threadRoot: input.resumeKey }),
+                ...(exitCode === 0 ? await nativeThreadContext?.checkpoint() ?? {} : {}),
                 sessionId,
                 lastRunAt: Date.now(),
-                turns: resuming ? (prior?.turns ?? 0) + 1 : 1,
+                turns: nativeThreadContext?.confirmed ? (prior?.turns ?? 0) + 1 : 1,
                 model: currentModel,
                 providerFingerprint: providerFp,
                 ...(input.sessionContextFingerprint === undefined
@@ -997,7 +1017,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             ...(usage === undefined ? {} : { usage }),
             model: observedModel,
             runtime: runtime.name,
-            resumed: resuming,
+            resumed: nativeThreadContext?.confirmed ?? false,
             sessionId,
             errorMessage: errorTail || null,
             ...(providerError === undefined ? {} : { providerError }),
@@ -1009,6 +1029,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         };
     }
     finally {
+        await nativeThreadContext?.cleanup().catch(() => undefined);
         startupReservationState.current?.release();
         try {
             await localMemoryTelemetry?.finish();

package/dist/local-memory/pending.js

@@ -1,11 +1,34 @@
 import { randomUUID } from "node:crypto";
-import { lstat, mkdir, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readdir, realpath, rename, rm, writeFile, readFile } from "node:fs/promises";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
-import { isRecallablePending, parsePendingMemoryCandidate } from "./pending-schema.js";
-import { pendingFileNames, pendingReadDirectory, PENDING_FILE_BYTES, readPendingSource } from "./pending-source.js";
-import { pendingRecallScore } from "./pending-match.js";
+import { z } from "zod";
 export const LOCAL_MEMORY_PENDING_SCAN_FILE_CAP = 128;
 export const LOCAL_MEMORY_PENDING_SCAN_BYTE_CAP = 1_000_000;
+const CandidateSchema = z.object({
+    operation: z.enum(["create", "update", "supersede"]),
+    memoryId: z.string().nullable(),
+    baseRevision: z.number().int().nonnegative().nullable(),
+    supersedesMemoryId: z.string().nullable(),
+    title: z.string().min(1),
+    kind: z.enum(["procedural", "semantic", "episodic", "preference"]),
+    summary: z.string().min(1),
+    triggers: z.array(z.string()).min(1),
+    priority: z.enum(["high", "medium", "low"]),
+    detailCategory: z.enum(["preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons"]),
+    detailBody: z.string().min(1),
+    reviewAfter: z.string().nullable(),
+}).strict();
+const PendingSchema = z.object({
+    schemaVersion: z.literal(1),
+    pendingId: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
+    createdAt: z.string().min(1),
+    reason: z.literal("index_over_budget"),
+    source: z.object({
+        executionId: z.string().min(1),
+        pruneTraceId: z.string().min(1).nullable(),
+    }).strict(),
+    candidate: CandidateSchema,
+}).strict();
 function within(root, candidate) {
     const path = relative(root, candidate);
     return path === "" || (path !== ".." && !path.startsWith(`..${sep}`));
@@ -99,11 +122,13 @@ async function atomicWrite(path, content) {
     }
 }
 export async function persistPendingMemoryCandidate(input) {
-    const parsed = parsePendingMemoryCandidate(input.candidate);
+    const parsed = PendingSchema.safeParse(input.candidate);
+    if (!parsed.success)
+        throw new Error("local_memory_pending_invalid");
     const directory = await pendingDirectory(input.agentDir);
-    const target = join(directory, `${parsed.pendingId}.json`);
+    const target = join(directory, `${parsed.data.pendingId}.json`);
     await assertRegularFile(target);
-    await atomicWrite(target, `${JSON.stringify(parsed, null, 2)}\n`);
+    await atomicWrite(target, `${JSON.stringify(parsed.data, null, 2)}\n`);
     return target;
 }
 export async function removePendingMemoryCandidate(input) {
@@ -115,44 +140,73 @@ export async function removePendingMemoryCandidate(input) {
     await rm(target, { force: true });
 }
 export async function readPendingMemoryCandidates(input) {
-    const { directory } = await pendingReadDirectory(input.agentDir).catch((error) => {
-        if (error instanceof Error && error.message === "memory_pending_path_invalid") {
-            throw new Error("local_memory_pending_path_invalid");
-        }
-        throw error;
-    });
-    const names = await pendingFileNames(directory);
+    const directory = await existingPendingDirectory(input.agentDir);
+    if (directory === null)
+        return [];
+    const names = (await readdir(directory)).filter((name) => name.endsWith(".json")).sort();
     const maxFiles = Math.max(0, input.maxFiles ?? LOCAL_MEMORY_PENDING_SCAN_FILE_CAP);
     const maxBytes = Math.max(0, input.maxBytes ?? LOCAL_MEMORY_PENDING_SCAN_BYTE_CAP);
     const result = [];
     let scannedBytes = 0;
-    for (const name of names.slice(0, maxFiles)) {
-        if (scannedBytes >= maxBytes)
+    for (const name of names) {
+        if (result.length >= maxFiles || scannedBytes >= maxBytes)
             break;
+        const path = join(directory, name);
         try {
-            const source = await readPendingSource(input.agentDir, name, maxBytes - scannedBytes);
-            scannedBytes += source.bytes;
-            result.push(source.candidate);
+            await assertRegularFile(path);
+            const stat = await lstat(path);
+            if (!stat.isFile() || stat.isSymbolicLink())
+                throw new Error("local_memory_pending_path_invalid");
+            if (scannedBytes + stat.size > maxBytes)
+                break;
+            const raw = await readFile(path, "utf8");
+            const size = Buffer.byteLength(raw, "utf8");
+            if (scannedBytes + size > maxBytes)
+                break;
+            scannedBytes += size;
+            const parsed = PendingSchema.safeParse(JSON.parse(raw));
+            if (parsed.success && `${parsed.data.pendingId}.json` === name)
+                result.push(parsed.data);
         }
         catch {
-            // 失败读取也消耗预算，显式分页命令负责返回诊断和继续扫描。
-            scannedBytes += Math.min(PENDING_FILE_BYTES, maxBytes - scannedBytes);
+            // A damaged pending item is diagnosable and must not hide other candidates.
         }
     }
     return result;
 }
+function normalize(value) {
+    return value.normalize("NFKC").toLocaleLowerCase().replace(/\s+/gu, " ").trim();
+}
 function priorityRank(priority) {
     return priority === "high" ? 0 : priority === "medium" ? 1 : 2;
 }
+function candidateText(candidate) {
+    return [
+        candidate.candidate.title,
+        candidate.candidate.summary,
+        ...candidate.candidate.triggers,
+        candidate.candidate.detailCategory,
+        candidate.candidate.detailBody,
+    ].join("\n");
+}
+function recallScore(candidate, query) {
+    const normalizedQuery = normalize(query);
+    if (normalizedQuery === "")
+        return 1;
+    const text = normalize(candidateText(candidate));
+    if (text.includes(normalizedQuery))
+        return 100;
+    const terms = normalizedQuery.split(/[\s,，、。！？；：:()[\]{}"'`]+/u).filter((term) => term.length > 0);
+    return terms.reduce((score, term) => score + (text.includes(term) ? 1 : 0), 0);
+}
 export async function searchPendingMemoryCandidates(input) {
     const candidates = await readPendingMemoryCandidates({ agentDir: input.agentDir });
     const limit = Math.max(0, input.limit ?? 5);
     if (limit === 0)
         return [];
     return candidates
-        .filter(isRecallablePending)
-        .map((candidate) => ({ candidate, score: pendingRecallScore(candidate, input.query) }))
-        .filter((item) => item.score > 0)
+        .map((candidate) => ({ candidate, score: recallScore(candidate, input.query) }))
+        .filter((item) => normalize(input.query) === "" || item.score > 0)
         .sort((left, right) => right.score - left.score
         || priorityRank(left.candidate.candidate.priority) - priorityRank(right.candidate.candidate.priority)
         || right.candidate.createdAt.localeCompare(left.candidate.createdAt)
@@ -164,29 +218,25 @@ function truncateCodePoints(value, maxCodePoints) {
     return Array.from(value).slice(0, Math.max(0, maxCodePoints)).join("");
 }
 export function renderPendingMemoryContext(candidates, maxCodePoints = 2_000) {
-    const recallable = candidates.filter(isRecallablePending);
-    if (recallable.length === 0 || maxCodePoints <= 0)
+    if (candidates.length === 0 || maxCodePoints <= 0)
         return "";
-    const header = `\n\n## Archived memory candidates (daemon-managed)\n容量暂存的新增资料，仅为部分预览，不代表完整检索；可参考但不能覆盖现行规则，未包含内容请按需查询。\n`;
+    const header = `\n\n## Archived memory candidates (daemon-managed)\n这些记忆已持久化，但尚未进入常驻热索引；只在当前请求相关时参考，必要时再由 memory-prune 提升。\n`;
     let remaining = maxCodePoints - Array.from(header).length;
     if (remaining <= 0)
         return truncateCodePoints(header, maxCodePoints);
     const sections = [];
-    for (const item of recallable) {
+    for (const item of candidates) {
         const change = item.candidate;
         const prefix = `\n### ${change.title}\n`
-            + `- pending_id: ${item.pendingId}\n`
+            + `- pending_file: .crew/memory/pending/${item.pendingId}.json\n`
             + `- summary: ${change.summary}\n`
             + `- triggers: ${change.triggers.join(", ")}\n`
             + "- detail: ";
         const prefixLength = Array.from(prefix).length;
         if (prefixLength + 1 > remaining)
             break;
-        const notice = " [正文未完，请用 read-pending 分页读取]";
-        const available = remaining - prefixLength - 1;
-        const truncated = Array.from(change.detailBody).length > available;
-        const detail = truncateCodePoints(change.detailBody, truncated ? Math.max(0, available - Array.from(notice).length) : available);
-        const section = `${prefix}${detail}${truncated ? truncateCodePoints(notice, available - Array.from(detail).length) : ""}\n`;
+        const detail = truncateCodePoints(change.detailBody, remaining - prefixLength - 1);
+        const section = `${prefix}${detail}\n`;
         const length = Array.from(section).length;
         sections.push(section);
         remaining -= length;

package/dist/local-memory/prompt.js

@@ -1,7 +1,6 @@
 import { dslog } from "../slog.js";
 import { renderPendingMemoryContext, searchPendingMemoryCandidates } from "./pending.js";
 import { renderLocalMemoryResultInstructions } from "./runtime.js";
-const PENDING_READ_GUIDANCE = "\n\nV2新增资料预览未命中不代表没有资料；先查有效索引，必要时用 crew-memory search-pending --query '关键词'，按 nextCursor 续查；用 read-pending --id ID 分页读正文。容量暂存资料不能覆盖现行规则，未应用修改不作为记忆。用 crew-memory --help 查看参数。\n";
 export async function prepareLocalMemoryPrompt(input) {
     let pending = "";
     if (input.enabled) {
@@ -22,18 +21,17 @@ export async function prepareLocalMemoryPrompt(input) {
     }
     const original = input.renderBase(0);
     const structured = input.resultPath === null ? "" : renderLocalMemoryResultInstructions(input.resultPath);
-    const guidance = input.enabled ? PENDING_READ_GUIDANCE : "";
-    // 短命令指引放在当前轮，独立于可舍弃预览；收尾契约仍保持系统与当前轮两份。
-    for (const choice of [
-        { suffix: pending + structured, wake: structured + guidance },
-        { suffix: structured, wake: structured + guidance },
-        { suffix: structured, wake: structured },
-    ]) {
-        const reserved = Buffer.byteLength(choice.suffix + choice.wake, "utf8");
-        const systemPrompt = (reserved === 0 ? original : input.renderBase(reserved)) + choice.suffix;
-        if (input.maxBytes === undefined || Buffer.byteLength(systemPrompt + choice.wake, "utf8") <= input.maxBytes) {
-            return { systemPrompt, resultPath: input.resultPath, wakePromptSuffix: choice.wake };
-        }
+    const wakeBytes = Buffer.byteLength(structured, "utf8");
+    const fits = (prompt) => input.maxBytes === undefined || Buffer.byteLength(prompt, "utf8") + wakeBytes <= input.maxBytes;
+    const render = (suffix) => (suffix === "" ? original : input.renderBase(Buffer.byteLength(suffix, "utf8") + wakeBytes)) + suffix;
+    // 系统及当前消息各保留一份契约，避免 resume 沿用旧指令；两份均先占预算，再裁可选预览。
+    const complete = render(pending + structured);
+    if (fits(complete))
+        return { systemPrompt: complete, resultPath: input.resultPath, wakePromptSuffix: structured };
+    if (pending !== "") {
+        const withoutPending = render(structured);
+        if (fits(withoutPending))
+            return { systemPrompt: withoutPending, resultPath: input.resultPath, wakePromptSuffix: structured };
     }
     // 强制基础指令与契约本身仍无法共存时，保留既有非结构化兼容回退，不裁基础指令。
     return { systemPrompt: original, resultPath: null, wakePromptSuffix: "" };

package/dist/local-memory/read-cli.js

@@ -5,7 +5,6 @@ import { isAbsolute, relative, resolve, sep } from "node:path";
 import { pathToFileURL } from "node:url";
 import { parseArgs, TextDecoder } from "node:util";
 import { z } from "zod";
-import { readPendingMemoryBody, searchPendingMemoryPage } from "./pending-query.js";
 const OUTPUT_BYTES = 12 * 1024;
 const FILE_BYTES = 32 * 1024 * 1024;
 const FileSchema = z.string().min(1).refine((file) => {
@@ -34,33 +33,14 @@ const CommandSchema = z.discriminatedUnion("command", [
         offset: z.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0),
         limit: z.coerce.number().int().min(1).max(4000).default(2000),
     }).strict(),
-    z.object({
-        command: z.literal("search-pending"),
-        query: z.string().trim().min(1).max(256),
-        cursor: z.string().min(1).max(4096).optional(),
-        limit: z.coerce.number().int().min(1).max(40).default(10),
-    }).strict(),
-    z.object({
-        command: z.literal("read-pending"),
-        id: z.string().min(1).max(250).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
-        ifHash: Common.ifHash,
-        offset: z.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0),
-        limit: z.coerce.number().int().min(1).max(4000).default(2000),
-    }).strict(),
 ]);
 const USAGE = `只读记忆工具，默认输出 JSON，不修改任何记忆文件。
 crew-memory search --query <关键词> [--file MEMORY.md|notes/文件.md] [--limit 10] [--after-line 0]
 crew-memory read [--file MEMORY.md|notes/文件.md] [--offset 0] [--limit 2000]
-crew-memory search-pending --query <关键词> [--cursor <游标>] [--limit 10]
-crew-memory read-pending --id <候选ID> [--offset 0] [--limit 2000] [--if-hash <sha256>]
-search 关键词按空白分隔，同一行须全部命中；返回完整文件中的行号和字符偏移。
+搜索关键词按空白分隔，同一行须全部命中；返回完整文件中的行号和字符偏移。
 读取的 offset/limit 按 Unicode 字符计数；用 nextOffset 继续，eof=true 表示结束。
 后续页可传 --if-hash <前一页的 sha256>，文件变化时停止，避免混读不同版本。
-search/read 读取 MEMORY.md 和 notes 原文，不过滤失效段落，也不扫描 pending。
-search-pending 只查因容量延期的 create 候选；有 nextCursor 就继续，即使本页 matches 为空。
-complete=true 才表示全部候选已检索完成且无遗漏；warnings 或非零退出码表示读取未完成，不能当作零命中。
-read-pending 只返回候选正文；offset 非零时必须传 --if-hash，update/supersede 候选不可读取。
-候选只供相关问题参考，未生效，不能覆盖有效规则；先读取当前有效索引与明细。`;
+搜索结果是原始资料定位，不代表候选已生效；按当前有效索引读取明细，不扫描 pending。`;
 function inside(root, path) {
     const value = relative(root, path);
     return value !== ".." && !value.startsWith(`..${sep}`) && !isAbsolute(value);
@@ -172,8 +152,8 @@ function searchSource(text, sha256, command) {
         nextAfterLine: hasMore ? matches.at(-1)?.line ?? null : null,
     };
 }
-function readPage(text, source, command) {
-    const metadata = { ...source, offset: command.offset, nextOffset: Number.MAX_SAFE_INTEGER, eof: false, content: "" };
+function readPage(text, sha256, command) {
+    const metadata = { file: command.file, sha256, offset: command.offset, nextOffset: Number.MAX_SAFE_INTEGER, eof: false, content: "" };
     let remaining = OUTPUT_BYTES - Buffer.byteLength(JSON.stringify(metadata), "utf8");
     let position = 0;
     let offset = 0;
@@ -195,16 +175,8 @@ function readPage(text, source, command) {
         count += 1;
     }
     const eof = position === text.length;
-    if (!eof && count === 0)
-        throw new Error("memory_output_too_large");
     return { ...metadata, content, eof, nextOffset: eof ? null : offset };
 }
-function writeResult(result, io) {
-    const output = JSON.stringify(result);
-    if (Buffer.byteLength(output, "utf8") > OUTPUT_BYTES)
-        throw new Error("memory_output_too_large");
-    io.out(output);
-}
 export async function runMemoryReadCommand(argv, io) {
     let command;
     try {
@@ -214,7 +186,6 @@ export async function runMemoryReadCommand(argv, io) {
                 query: { type: "string", short: "q" }, file: { type: "string" },
                 limit: { type: "string" }, offset: { type: "string" },
                 "after-line": { type: "string" }, "if-hash": { type: "string" },
-                id: { type: "string" }, cursor: { type: "string" },
                 json: { type: "boolean" }, help: { type: "boolean", short: "h" },
             },
         });
@@ -230,44 +201,24 @@ export async function runMemoryReadCommand(argv, io) {
             ...(afterLine === undefined ? {} : { afterLine }),
             ...(ifHash === undefined ? {} : { ifHash }),
         });
-        if (command.command === "read-pending" && command.offset > 0 && command.ifHash === undefined) {
-            throw new Error("memory_hash_required");
-        }
     }
     catch {
-        io.err(`memory_arguments_invalid: 参数不合法，记忆读取未完成。\n${USAGE}`);
+        io.err(`memory_arguments_invalid: 参数不合法。\n${USAGE}`);
         return 2;
     }
     try {
-        if (!io.env.CREW_HOME)
-            throw new Error("memory_home_missing");
-        if (command.command === "search-pending") {
-            const result = await searchPendingMemoryPage({ agentDir: io.env.CREW_HOME, query: command.query,
-                ...(command.cursor === undefined ? {} : { cursor: command.cursor }), limit: command.limit });
-            writeResult(result, io);
-            if (result.warnings.length > 0 || (!result.hasMore && !result.complete)) {
-                throw new Error("memory_pending_search_incomplete");
-            }
-            return 0;
-        }
-        if (command.command === "read-pending") {
-            const { content, ...metadata } = await readPendingMemoryBody({ agentDir: io.env.CREW_HOME,
-                pendingId: command.id, ...(command.ifHash === undefined ? {} : { ifHash: command.ifHash }) });
-            writeResult(readPage(content, metadata, command), io);
-            return 0;
-        }
         const source = await readSource(io.env.CREW_HOME, command.file);
         if (command.ifHash !== undefined && command.ifHash !== source.sha256)
             throw new Error("memory_file_changed");
         const result = command.command === "search"
             ? searchSource(source.text, source.sha256, command)
-            : readPage(source.text, { file: command.file, sha256: source.sha256 }, command);
-        writeResult(result, io);
+            : readPage(source.text, source.sha256, command);
+        io.out(JSON.stringify(result));
         return 0;
     }
     catch (error) {
         const code = error.code;
-        const known = error instanceof Error && /^(?:local_)?memory_[a-z_]+$/u.test(error.message) ? error.message : code ?? "memory_read_failed";
+        const known = error instanceof Error && /^memory_[a-z_]+$/u.test(error.message) ? error.message : code ?? "memory_read_failed";
         io.err(JSON.stringify({ error: known, message: "记忆读取未完成；检查路径、文件版本或大小，不要将此错误当作没有记忆。" }));
         return 1;
     }

package/dist/local-memory/runtime.js

@@ -69,8 +69,8 @@ outcome 只允许 no_change、proposed、conflict、failed。新增、更新、
 \`\`\`
 
 每个 changes 项须保留示例中的全部字段。operation=create|update|supersede；kind=procedural|semantic|episodic|preference；priority=high|medium|low；detailCategory=preferences|project-rules|testing|debugging|git|incidents|lessons。create 的 memoryId/baseRevision/supersedesMemoryId 必须为 null；update 按现有索引填写 memoryId/baseRevision，supersedesMemoryId 为 null；supersede 填 supersedesMemoryId/baseRevision，memoryId 为 null。
-只提交可复用、与本次任务明确相关的少量候选；不要写入凭证、token、隐私或内部控制标记。daemon 会校验、去重、限制 MEMORY.md 大小，超出索引容量的候选会保存在 pending 归档中。容量暂存的 create 可按需检索参考但不能覆盖现行规则；有空间的后续 proposed 提交可提升。未应用的 update/supersede 不进入普通召回，必须重新核对目标版本后处理。
-写入候选文件只表示提交候选，不能提前宣称已经记住或规则已经更新；daemon 在本轮结束后才处理，候选持久化与进入有效索引也不是同一结果。本结构化轮次覆盖前文提前清理工作日志的要求：保留 $CREW_TASK_LOG，不要清空或删除；daemon 将在处理成功后清理，失败时保留日志和候选用于排查或重试。
+只提交可复用、与本次任务明确相关的少量候选；不要写入凭证、token、隐私或内部控制标记。daemon 会校验、去重、限制 MEMORY.md 大小，超出索引容量的候选会保存在 pending 归档中；后续相关任务会按需召回，索引腾出空间后可自动提升。
+写入候选文件不等于已经记住，只有 daemon 校验并提交成功后记忆才生效。本结构化轮次覆盖前文提前清理工作日志的要求：保留 $CREW_TASK_LOG，不要清空或删除；daemon 将在提交成功后清理，失败时保留日志和候选用于排查或重试。
 `;
 }
 /** Prevent ordinary V2 turns from racing the daemon-managed memory writer. */