@nowcrew/daemon 0.6.87 → 0.6.88-beta.10

package/dist/local-executor.js

@@ -12,8 +12,11 @@ import { spawnKimi, KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
 import { applyDeepSeekHarnessMachineEnv, applyProviderEnv, providerFingerprint, } from "./provider-env.js";
 import { augmentedPath } from "./runtime-path.js";
 import { deliverCloudReports, prepareCloudReportExecution } from "./cloud-report-uploader.js";
+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";
@@ -34,10 +37,11 @@ import { diffMemoryPruneNotes, evaluateMemoryPrunePostcondition, inspectMemoryPr
 import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLocalMemoryDiagnosticsFailure, } from "./local-memory-telemetry.js";
 import { CodexStartupStageParser } from "./codex-startup-stage.js";
 import { formatRuntimeStartupError } from "./runtime-startup-error.js";
-import { machinePackageManagerEnv, packageManagerEnvFacts } from "./package-manager-env.js";
+import { machinePackageManagerEnv } from "./package-manager-env.js";
+import { logRuntimeEnvironmentContract } from "./runtime-environment-telemetry.js";
 import { sanitizeEnvVars } from "./runtime-env.js";
-import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, renderLocalMemoryResultInstructions, } from "./local-memory/runtime.js";
-import { renderPendingMemoryContext, searchPendingMemoryCandidates, } from "./local-memory/pending.js";
+import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, } from "./local-memory/runtime.js";
+import { prepareLocalMemoryPrompt } from "./local-memory/prompt.js";
 export class RuntimeRunningCallbackTimeoutError extends Error {
     constructor(runtime, timeoutMs) {
         super(`${runtime} runtime-running callback timed out after ${timeoutMs}ms`);
@@ -106,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,
@@ -173,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")) {
@@ -253,9 +261,15 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     let localMemoryResultPath = null;
     let executionWorkspace = workspace;
     let localMemoryTelemetry = null;
+    let nativeThreadContext = null;
     const inheritedEnv = { ...process.env };
-    const cloudReportPreparation = await prepareCloudReportExecution({ env: inheritedEnv, root: workspace.dir, executionId: input.executionId, agentHandle: input.handle });
+    const reportRoots = {
+        root: workspace.dir,
+        ...(input.launch.qaReportRoot === undefined ? {} : { qaReportRoot: input.launch.qaReportRoot }),
+    };
+    const cloudReportPreparation = await prepareCloudReportExecution({ env: inheritedEnv, ...reportRoots, executionId: input.executionId, agentHandle: input.handle });
     const { facts: cloudReportUpload, snapshot: reportSnapshot } = cloudReportPreparation;
+    const reportContext = reportDeliveryContext(input.executionId, workspace.runDir, cloudReportUpload);
     for (const key of Object.keys(inheritedEnv)) {
         if (key.startsWith("CREW_AGENT_MEMORY_") || ["CREW_CLOUD_PROVIDER", "CREW_OSS_UPLOAD_SCRIPT", "CREW_OSS_REPORT_UPLOAD"].includes(key))
             delete inheritedEnv[key];
@@ -287,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"
@@ -308,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));
@@ -329,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
@@ -381,28 +396,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             }
         }
         const attachmentPlan = routeRuntimeAttachments(runtime.name, materialized?.attachments ?? []);
-        const wakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
-        let pendingMemoryContext = "";
-        if (input.localMemoryV2Enabled === true) {
-            try {
-                const pendingCandidates = await searchPendingMemoryCandidates({
-                    agentDir: executionWorkspace.dir,
-                    query: wakePrompt,
-                    limit: 5,
-                });
-                pendingMemoryContext = renderPendingMemoryContext(pendingCandidates);
-            }
-            catch (error) {
-                dslog("local_memory.pending_recall_failed", "本地归档记忆召回失败", {
-                    level: "WARN",
-                    execution_id: input.executionId,
-                    agent_handle: input.handle,
-                    error_name: error instanceof Error ? error.name : "unknown",
-                    error_code: error?.code,
-                });
-            }
-        }
-        memoryPruneTraceId = parseMemoryPruneTraceId(wakePrompt);
+        const baseWakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
+        memoryPruneTraceId = parseMemoryPruneTraceId(baseWakePrompt);
         if (input.localMemoryV2Enabled === true && memoryPruneTraceId !== null
             && isLocalMemoryV2Eligible({
                 enabledForHandle: true,
@@ -413,26 +408,15 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             })) {
             localMemoryResultPath = makeLocalMemoryResultPath(executionWorkspace.runDir, input.executionId);
         }
-        const promptWithoutPending = resolvePrompt(input.systemPrompt, promptContext);
-        let baseSystemPrompt = `${promptWithoutPending}${pendingMemoryContext}`;
-        const structuredMemoryInstructions = localMemoryResultPath === null
-            ? null
-            : renderLocalMemoryResultInstructions(localMemoryResultPath);
-        const fitsPromptBudget = (prompt) => structuredMemoryInstructions === null
-            || input.maxSystemPromptBytes === undefined
-            || Buffer.byteLength(prompt, "utf8") + Buffer.byteLength(structuredMemoryInstructions, "utf8")
-                <= input.maxSystemPromptBytes;
-        // The structured prune contract is mandatory for V2. Drop optional archived
-        // recall before dropping the daemon result file when the prompt budget is tight.
-        if (!fitsPromptBudget(baseSystemPrompt) && pendingMemoryContext !== "") {
-            baseSystemPrompt = promptWithoutPending;
-        }
-        const structuredPromptFits = fitsPromptBudget(baseSystemPrompt);
-        if (!structuredPromptFits)
-            localMemoryResultPath = null;
-        const systemPrompt = localMemoryResultPath === null
-            ? baseSystemPrompt
-            : `${baseSystemPrompt}${structuredMemoryInstructions ?? ""}`;
+        const memoryPrompt = await prepareLocalMemoryPrompt({
+            agentDir: executionWorkspace.dir, executionId: input.executionId, agentHandle: input.handle,
+            enabled: input.localMemoryV2Enabled === true, query: baseWakePrompt,
+            resultPath: localMemoryResultPath, maxBytes: input.maxSystemPromptBytes,
+            renderBase: (reservedPromptBytes) => resolvePrompt(input.systemPrompt, { ...promptContext, reservedPromptBytes }),
+        });
+        localMemoryResultPath = memoryPrompt.resultPath;
+        const systemPrompt = memoryPrompt.systemPrompt;
+        const wakePrompt = baseWakePrompt + memoryPrompt.wakePromptSuffix;
         if (!isolatedMaintenance)
             try {
                 localMemoryTelemetry = createLocalMemoryTelemetry({
@@ -491,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),
@@ -503,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
@@ -513,6 +505,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             // Expose only the training root; ability-specific workspace layout stays
             // owned by the training package rather than the NowWork daemon.
             QA_RUNTIME_ROOT: join(crewHome, "training"),
+            QA_REPORT_DELIVERY_CONTEXT: JSON.stringify(reportContext),
             CREW_TASK_DIR: executionWorkspace.runDir,
             CREW_TASK_LOG: executionWorkspace.workLogPath,
             ...(input.wakeMessageId ? { CREW_WAKE_MESSAGE_ID: input.wakeMessageId } : {}),
@@ -532,30 +525,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const childEnv = runtime.name === "deepseek-harness"
             ? applyDeepSeekHarnessMachineEnv(providerEnv, inheritedEnv)
             : providerEnv;
-        dslog("runtime.environment_contract", "Runtime 子进程环境契约", {
-            execution_id: input.executionId,
-            agent_handle: input.handle,
-            runtime: runtime.name,
-            qa_runtime_root: childEnv.QA_RUNTIME_ROOT ?? null,
-            qa_runtime_root_present: childEnv.QA_RUNTIME_ROOT !== undefined,
-            inherited_qa_runtime_root_present: inheritedEnv.QA_RUNTIME_ROOT !== undefined,
-            ...packageManagerEnvFacts(childEnv),
-            training_root: join(crewHome, "training"),
-            cloud_provider: cloudReportUpload.provider,
-            oss_report_upload_enabled: cloudReportUpload.enabled,
-            project_context_present: input.projectContext !== undefined,
-            project_ids: JSON.stringify(input.projectContext === undefined
-                ? []
-                : [
-                    ...(input.projectContext.primary === undefined
-                        ? []
-                        : [input.projectContext.primary.projectId]),
-                    ...input.projectContext.secondary.map((project) => project.projectId),
-                ]),
-            ability_release_present: input.abilityRelease !== undefined,
-            ability_release_id: input.abilityRelease?.releaseId,
-            ability_root_commit: input.abilityRelease?.rootCommit,
-        });
+        logRuntimeEnvironmentContract(input, childEnv, inheritedEnv, crewHome, cloudReportUpload);
         const warn = dependencies.warnRuntime ?? warnRuntimeLocally;
         const launchRuntime = dependencies.launchRuntime ?? (async (launchReq) => {
             if (launchReq.runtime === "codex" && launchReq.codexCollaborationTools === true) {
@@ -572,7 +542,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             const effectiveSystemPrompt = abilityContext === undefined
                 ? systemPrompt
                 : `${systemPrompt}\n\n${abilityContext.prompt}`;
-            if (Buffer.byteLength(effectiveSystemPrompt, "utf8") > (input.maxSystemPromptBytes ?? Number.MAX_SAFE_INTEGER)) {
+            if (Buffer.byteLength(effectiveSystemPrompt, "utf8") + Buffer.byteLength(memoryPrompt.wakePromptSuffix, "utf8")
+                > (input.maxSystemPromptBytes ?? Number.MAX_SAFE_INTEGER)) {
                 throw new Error("ability_runtime_context_size_exceeded");
             }
             memoryPruneFailurePhase = "prompt_write";
@@ -848,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();
@@ -964,22 +936,27 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         localMemoryTelemetry?.markRuntimeExited(exitCode);
         memoryPruneRuntimeExitCode = exitCode;
         if (localMemoryResultPath !== null) {
+            memoryPruneFailurePhase = "memory_commit";
             const committed = await commitLocalMemoryResultAfterExit({
                 resultPath: localMemoryResultPath,
                 agentDir: executionWorkspace.dir,
                 executionId: input.executionId,
                 pruneTraceId: memoryPruneTraceId,
                 exitCode,
+                workLogPath: executionWorkspace.workLogPath,
             });
-            if (committed.status === "failed") {
-                dslog("local_memory.commit_failed", "结构化本地记忆候选未落地，保留结果文件", {
-                    level: "WARN",
+            if (committed.status === "failed" || committed.status === "missing") {
+                const reason = committed.error ?? "local_memory_result_missing";
+                dslog("local_memory.commit_failed", "结构化本地记忆提交或清理未完成，保留可用恢复材料", {
+                    level: "ERROR",
                     execution_id: input.executionId,
                     agent_handle: input.handle,
-                    error_code: committed.error,
+                    error_code: reason,
                     result_path: localMemoryResultPath,
                 });
+                throw new Error(`local_memory_commit_failed: ${reason}`);
             }
+            memoryPruneFailurePhase = "runtime_finalize";
         }
         const errorTail = [
             stderrTail.trim(),
@@ -1001,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
@@ -1018,7 +998,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         }
         const cloudReportResult = exitCode === 0
             ? await deliverCloudReports({
-                facts: cloudReportUpload, root: workspace.dir, before: reportSnapshot, finalText,
+                facts: cloudReportUpload, ...reportRoots, before: reportSnapshot, finalText,
+                receiptFile: reportContext.receiptFile,
                 externalAnswer: externalOutput.lastClosedBlock
                     ?? (finalText === null ? null : extractExternalAnswer(finalText)),
                 captureFinal: input.captureFinal, executionId: input.executionId, agentHandle: input.handle,
@@ -1036,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 }),
@@ -1048,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/candidate.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { containsLikelySecret } from "../agent-memory/policy.js";
+const CategorySchema = z.enum([
+    "preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons",
+]);
+export const LocalMemorySingleLineText = z.string().trim().min(1).max(500).regex(/^[^\r\n]+$/u);
+export const LocalMemoryChangeSchema = z.object({
+    operation: z.enum(["create", "update", "supersede"]),
+    memoryId: LocalMemorySingleLineText.regex(/^[^<>]+$/u).nullable(),
+    baseRevision: z.number().int().nonnegative().nullable(),
+    supersedesMemoryId: LocalMemorySingleLineText.regex(/^[^<>]+$/u).nullable(),
+    title: LocalMemorySingleLineText.max(120),
+    kind: z.enum(["procedural", "semantic", "episodic", "preference"]),
+    summary: LocalMemorySingleLineText,
+    triggers: z.array(LocalMemorySingleLineText.max(80)).min(1).max(16),
+    priority: z.enum(["high", "medium", "low"]),
+    detailCategory: CategorySchema,
+    detailBody: z.string().trim().min(1).max(12_000),
+    reviewAfter: LocalMemorySingleLineText.nullable(),
+}).strict();
+const CONTROL_CHARACTER_PATTERN = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u;
+const RESERVED_MEMORY_MARKER = /NOWWORK:(?:MEMORY_ENTRY|MEMORY_INDEX):/iu;
+export function validateLocalMemoryChange(change) {
+    const text = [change.title, change.summary, ...change.triggers, change.detailBody].join("\n");
+    if (containsLikelySecret(text))
+        throw new Error("local_memory_secret_candidate");
+    if (CONTROL_CHARACTER_PATTERN.test(text))
+        throw new Error("local_memory_control_character");
+    if (RESERVED_MEMORY_MARKER.test(text))
+        throw new Error("local_memory_reserved_marker");
+    if (change.operation === "create"
+        && (change.memoryId !== null || change.baseRevision !== null || change.supersedesMemoryId !== null)) {
+        throw new Error("local_memory_create_revision_invalid");
+    }
+    if (change.operation === "update"
+        && (change.memoryId === null || change.baseRevision === null || change.supersedesMemoryId !== null)) {
+        throw new Error("local_memory_update_revision_missing");
+    }
+    if (change.operation === "supersede"
+        && (change.memoryId !== null || change.baseRevision === null || change.supersedesMemoryId === null)) {
+        throw new Error("local_memory_supersede_revision_missing");
+    }
+}

package/dist/local-memory/pending-match.js

@@ -0,0 +1,29 @@
+export function normalizePendingQuery(value) {
+    return value.normalize("NFKC").toLocaleLowerCase().replace(/\s+/gu, " ").trim();
+}
+function containsTerm(text, term) {
+    if (!term)
+        return false;
+    const startBoundary = /^[a-z0-9]/u.test(term);
+    const endBoundary = /[a-z0-9]$/u.test(term);
+    let position = text.indexOf(term);
+    while (position >= 0) {
+        const before = text[position - 1] ?? "";
+        const after = text[position + term.length] ?? "";
+        if ((!startBoundary || !/[a-z0-9_-]/u.test(before)) && (!endBoundary || !/[a-z0-9_-]/u.test(after)))
+            return true;
+        position = text.indexOf(term, position + 1);
+    }
+    return false;
+}
+export function pendingRecallScore(item, query) {
+    const normalized = normalizePendingQuery(query);
+    if (!normalized)
+        return 0;
+    const candidate = item.candidate;
+    const terms = normalized.split(/[\s,，、。！？；：:()[\]{}"'`]+/u).filter(Boolean);
+    const text = normalizePendingQuery([candidate.title, candidate.summary, ...candidate.triggers, candidate.detailCategory, candidate.detailBody].join("\n"));
+    const explicit = [candidate.title, ...candidate.triggers].map(normalizePendingQuery);
+    const explicitScore = explicit.reduce((score, term) => score + (containsTerm(normalized, term) ? 10 : 0), 0);
+    return explicitScore + terms.reduce((score, term) => score + (containsTerm(text, term) ? 1 : 0), 0);
+}

package/dist/local-memory/pending-query.js

@@ -0,0 +1,100 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { isRecallablePending, PendingIdSchema } from "./pending-schema.js";
+import { normalizePendingQuery, pendingRecallScore } from "./pending-match.js";
+import { pendingDirectorySnapshot, pendingSourceError, PENDING_FILE_BYTES, readPendingSource } from "./pending-source.js";
+const PAGE_FILES = 128;
+const PAGE_BYTES = 1_000_000;
+const OUTPUT_BYTES = 12 * 1024;
+const CursorSchema = z.object({
+    v: z.literal(1), queryHash: z.string().regex(/^[a-f0-9]{64}$/u), version: z.string().regex(/^[a-f0-9]{64}$/u),
+    after: z.string().min(1).max(255), hadWarnings: z.boolean(),
+}).strict();
+const SearchSchema = z.object({
+    agentDir: z.string().min(1), query: z.string().trim().min(1).max(256),
+    cursor: z.string().max(2048).optional(), limit: z.number().int().min(1).max(40).default(10),
+}).strict();
+const excerpt = (text, cap) => Array.from(text).slice(0, cap).join("");
+export async function searchPendingMemoryPage(input) {
+    const parsed = SearchSchema.safeParse(input);
+    if (!parsed.success)
+        throw new Error("memory_pending_arguments_invalid");
+    const args = parsed.data;
+    const queryHash = createHash("sha256").update(normalizePendingQuery(args.query)).digest("hex");
+    let cursor;
+    if (args.cursor !== undefined) {
+        try {
+            cursor = CursorSchema.parse(JSON.parse(Buffer.from(args.cursor, "base64url").toString("utf8")));
+        }
+        catch {
+            throw new Error("memory_pending_cursor_invalid");
+        }
+        if (cursor.queryHash !== queryHash)
+            throw new Error("memory_pending_cursor_invalid");
+    }
+    const snapshot = await pendingDirectorySnapshot(args.agentDir);
+    if (cursor && cursor.version !== snapshot.version)
+        throw new Error("memory_pending_source_changed");
+    const initial = cursor ? snapshot.names.indexOf(cursor.after) + 1 : 0;
+    if (cursor && initial === 0)
+        throw new Error("memory_pending_cursor_invalid");
+    const matches = [];
+    const warnings = [];
+    let position = initial;
+    let scannedFiles = 0;
+    let scannedBytes = 0;
+    // 为游标、错误与元数据预留空间；达到输出上限前停止消费来源，不跳过未输出的命中。
+    let outputBytes = 1600;
+    while (position < snapshot.names.length && scannedFiles < PAGE_FILES && scannedBytes + PENDING_FILE_BYTES <= PAGE_BYTES) {
+        const name = snapshot.names[position];
+        let source;
+        let warning;
+        try {
+            source = await readPendingSource(args.agentDir, name);
+        }
+        catch (error) {
+            const code = pendingSourceError(error);
+            if (code === "memory_pending_source_changed" || code === "memory_pending_not_found")
+                throw new Error("memory_pending_source_changed");
+            warning = { file: name, code };
+        }
+        const match = source && isRecallablePending(source.candidate) && pendingRecallScore(source.candidate, args.query) > 0
+            ? { pendingId: source.candidate.pendingId, sha256: source.sha256, title: source.candidate.candidate.title,
+                summary: excerpt(source.candidate.candidate.summary, 180), triggers: source.candidate.candidate.triggers.slice(0, 4),
+                operation: "create", state: "capacity_deferred" }
+            : null;
+        const addition = match ?? warning;
+        const size = addition ? Buffer.byteLength(JSON.stringify(addition), "utf8") + 2 : 0;
+        if (outputBytes + size > OUTPUT_BYTES)
+            break;
+        if (match)
+            matches.push(match);
+        if (warning)
+            warnings.push(warning);
+        outputBytes += size;
+        scannedFiles += 1;
+        scannedBytes += source?.bytes ?? PENDING_FILE_BYTES;
+        position += 1;
+        if (matches.length >= args.limit)
+            break;
+    }
+    if ((await pendingDirectorySnapshot(args.agentDir)).version !== snapshot.version)
+        throw new Error("memory_pending_source_changed");
+    const hasMore = position < snapshot.names.length;
+    const hadWarnings = cursor?.hadWarnings === true || warnings.length > 0;
+    const nextCursor = hasMore ? Buffer.from(JSON.stringify({ v: 1, queryHash, version: snapshot.version,
+        after: snapshot.names[position - 1], hadWarnings })).toString("base64url") : null;
+    return { matches, warnings, scannedFiles, scannedBytes, hasMore, nextCursor, complete: !hasMore && !hadWarnings };
+}
+export async function readPendingMemoryBody(input) {
+    if (!PendingIdSchema.safeParse(input.pendingId).success)
+        throw new Error("memory_pending_id_invalid");
+    const source = await readPendingSource(input.agentDir, `${input.pendingId}.json`);
+    if (input.ifHash !== undefined && input.ifHash !== source.sha256)
+        throw new Error("memory_pending_source_changed");
+    if (!isRecallablePending(source.candidate))
+        throw new Error("memory_pending_not_recallable");
+    const candidate = source.candidate.candidate;
+    return { pendingId: source.candidate.pendingId, sha256: source.sha256, title: candidate.title,
+        operation: "create", state: "capacity_deferred", content: candidate.detailBody };
+}

package/dist/local-memory/pending-schema.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { LocalMemoryChangeSchema, validateLocalMemoryChange } from "./candidate.js";
+// 索引会按分隔符展开触发词；16 个最多 80 UTF-16 单元的输入可产生 0..640 项。
+const ArchivedMemoryChangeSchema = LocalMemoryChangeSchema.extend({
+    triggers: z.array(LocalMemoryChangeSchema.shape.triggers.element).max(640)
+        .refine((triggers) => triggers.reduce((length, trigger) => length + trigger.length, 0) <= 16 * 80),
+});
+export const PendingIdSchema = z.string().max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u);
+export const PendingMemorySchema = z.object({
+    schemaVersion: z.literal(1), pendingId: PendingIdSchema,
+    createdAt: z.string().min(1).max(100), reason: z.literal("index_over_budget"),
+    source: z.object({ executionId: z.string().min(1).max(500), pruneTraceId: z.string().min(1).max(500).nullable() }).strict(),
+    candidate: ArchivedMemoryChangeSchema,
+}).strict();
+export function parsePendingMemoryCandidate(value) {
+    const parsed = PendingMemorySchema.safeParse(value);
+    if (!parsed.success)
+        throw new Error("local_memory_pending_invalid");
+    validateLocalMemoryChange(parsed.data.candidate);
+    return parsed.data;
+}
+export function isRecallablePending(value) {
+    try {
+        return parsePendingMemoryCandidate(value).candidate.operation === "create";
+    }
+    catch {
+        return false;
+    }
+}

package/dist/local-memory/pending-source.js

@@ -0,0 +1,126 @@
+import { constants } from "node:fs";
+import { lstat, open, opendir, realpath } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { TextDecoder } from "node:util";
+import { parsePendingMemoryCandidate, PendingIdSchema } from "./pending-schema.js";
+export const PENDING_FILE_BYTES = 128 * 1024;
+const DIRECTORY_ENTRY_CAP = 10_000;
+export function pendingSourceError(error) {
+    if (error instanceof Error && /^memory_pending_[a-z_]+$/u.test(error.message))
+        return error.message;
+    return "memory_pending_file_invalid";
+}
+export async function pendingReadDirectory(agentDir) {
+    const root = await realpath(agentDir);
+    let directory = root;
+    for (const part of [".crew", "memory", "pending"]) {
+        directory = join(directory, part);
+        let stat;
+        try {
+            stat = await lstat(directory);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return { root, directory: null };
+            throw new Error("memory_pending_directory_unreadable");
+        }
+        if (!stat.isDirectory() || stat.isSymbolicLink() || await realpath(directory) !== directory) {
+            throw new Error("memory_pending_path_invalid");
+        }
+    }
+    return { root, directory };
+}
+export async function pendingFileNames(directory) {
+    if (directory === null)
+        return [];
+    const names = [];
+    let inspected = 0;
+    try {
+        for await (const item of await opendir(directory)) {
+            if (++inspected > DIRECTORY_ENTRY_CAP)
+                throw new Error("memory_pending_directory_over_budget");
+            if (item.name.endsWith(".json"))
+                names.push(item.name);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith("memory_pending_"))
+            throw error;
+        throw new Error("memory_pending_directory_unreadable");
+    }
+    return names.sort();
+}
+function version(stat) {
+    return [stat.dev, stat.ino, stat.mode, stat.size, stat.mtimeMs, stat.ctimeMs].join(":");
+}
+export async function pendingDirectorySnapshot(agentDir) {
+    const location = await pendingReadDirectory(agentDir);
+    const names = await pendingFileNames(location.directory);
+    const digest = createHash("sha256").update(location.root);
+    if (location.directory !== null)
+        digest.update(version(await lstat(location.directory)));
+    for (const name of names) {
+        try {
+            digest.update(JSON.stringify([name, version(await lstat(join(location.directory, name)))]));
+        }
+        catch {
+            throw new Error("memory_pending_source_changed");
+        }
+    }
+    return { ...location, names, version: digest.digest("hex") };
+}
+export async function readPendingSource(agentDir, name, byteBudget = PENDING_FILE_BYTES) {
+    if (!name.endsWith(".json") || !PendingIdSchema.safeParse(name.slice(0, -5)).success) {
+        throw new Error("memory_pending_id_invalid");
+    }
+    const { directory } = await pendingReadDirectory(agentDir);
+    if (directory === null)
+        throw new Error("memory_pending_not_found");
+    const path = join(directory, name);
+    const before = await lstat(path).catch(() => { throw new Error("memory_pending_not_found"); });
+    if (!before.isFile() || before.isSymbolicLink())
+        throw new Error("memory_pending_path_invalid");
+    const limit = Math.min(byteBudget, PENDING_FILE_BYTES);
+    if (before.size > limit)
+        throw new Error("memory_pending_file_over_budget");
+    const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+    try {
+        const opened = await handle.stat();
+        if (!opened.isFile() || version(opened) !== version(before))
+            throw new Error("memory_pending_source_changed");
+        const chunks = [];
+        let bytes = 0;
+        for (;;) {
+            const chunk = Buffer.alloc(Math.min(16 * 1024, limit + 1 - bytes));
+            const { bytesRead } = await handle.read(chunk, 0, chunk.length, null);
+            if (bytesRead === 0)
+                break;
+            bytes += bytesRead;
+            if (bytes > limit)
+                throw new Error("memory_pending_file_over_budget");
+            chunks.push(chunk.subarray(0, bytesRead));
+        }
+        const after = await handle.stat();
+        const currentDirectory = await pendingReadDirectory(agentDir);
+        const current = await lstat(path);
+        if (currentDirectory.directory !== directory || version(after) !== version(opened) || version(current) !== version(opened)) {
+            throw new Error("memory_pending_source_changed");
+        }
+        const buffer = Buffer.concat(chunks);
+        let parsed;
+        try {
+            const raw = new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+            parsed = parsePendingMemoryCandidate(JSON.parse(raw));
+        }
+        catch {
+            throw new Error("memory_pending_file_invalid");
+        }
+        if (`${parsed.pendingId}.json` !== name)
+            throw new Error("memory_pending_id_invalid");
+        return { candidate: parsed, bytes, sha256: createHash("sha256").update(buffer).digest("hex") };
+    }
+    finally {
+        await handle.close();
+    }
+}