@tea-agent/loop-agent 0.43.0-next.17 → 0.43.0-next.3

package/dist/task/source-references.js

@@ -5,7 +5,7 @@
  * source/references/, separate from the derived source/需求.md contract.
  */
 import { createHash } from "node:crypto";
-import { access, copyFile, lstat, mkdir, readdir, readFile, writeFile, } from "node:fs/promises";
+import { access, copyFile, mkdir, readdir, readFile, writeFile, } from "node:fs/promises";
 import path from "node:path";
 import { getTaskPaths, loadTaskConfig } from "./runtime.js";
 import { writeTaskConfig } from "../infrastructure/harness/task-store.js";
@@ -87,7 +87,6 @@ export async function materializeTaskReferenceDocs(input) {
     const referenceDir = path.join(paths.sourceDir, SOURCE_REFERENCE_DIRECTORY);
     await mkdir(referenceDir, { recursive: true });
     const materialized = [];
-    const manifest = await readSourceManifest(paths.sourceDir);
     for (const doc of docs) {
         const absoluteSource = path.isAbsolute(doc.path)
             ? doc.path
@@ -95,10 +94,7 @@ export async function materializeTaskReferenceDocs(input) {
         await assertReadableFile(absoluteSource, `referenceDocs entry "${doc.name ?? doc.path}"`);
         const extension = path.extname(absoluteSource) || ".md";
         const baseName = slugifyName(doc.name ?? path.basename(absoluteSource, extension));
-        const imported = manifest?.documents.find((entry) => path.basename(entry.materializedPath, path.extname(entry.materializedPath)) === baseName);
-        const targetName = imported
-            ? path.basename(imported.materializedPath)
-            : `${baseName}${extension}`;
+        const targetName = `${baseName}${extension}`;
         const targetPath = path.join(referenceDir, targetName);
         try {
             await access(targetPath);
@@ -136,23 +132,14 @@ export async function importPrdDocument(input) {
     catch {
         // directory may be empty / just created
     }
-    // Search every immutable reference, including suffixed and renamed imports.
-    // Roles remain distinct: identical bytes must not erase a constraint/AC role.
-    const matching = existingManifest?.documents.find((doc) => doc.role === role && doc.sha256 === hash.sha256 && doc.bytes === hash.bytes);
-    if (matching) {
-        const candidate = path.resolve(paths.sourceDir, matching.materializedPath);
-        if (path.dirname(candidate) !== path.resolve(referenceDir)) {
-            throw new Error(`REFERENCE_PATH_UNSAFE: ${matching.materializedPath}`);
-        }
-        const stats = await lstat(candidate);
-        if (!stats.isFile() || stats.isSymbolicLink() ||
-            !(await sameHashIfExists(candidate, hash.sha256))) {
-            throw new Error(`REFERENCE_HASH_MISMATCH: ${matching.materializedPath}`);
-        }
-    }
-    const targetFileName = matching
-        ? path.basename(matching.materializedPath)
-        : ensureUniqueReferenceName(existingNames, requestedName, extension);
+    // Prefer stable name "requirement.md" when free; otherwise suffix.
+    const preferredName = `${requestedName}${extension}`;
+    const targetFileName = existingNames.has(preferredName)
+        ? // If the same content is already there, reuse; else unique name.
+            (await sameHashIfExists(path.join(referenceDir, preferredName), hash.sha256))
+                ? preferredName
+                : ensureUniqueReferenceName(existingNames, requestedName, extension)
+        : preferredName;
     const targetPath = path.join(referenceDir, targetFileName);
     if (!(await fileExists(targetPath))) {
         await writeFile(targetPath, hash.content);
@@ -162,7 +149,7 @@ export async function importPrdDocument(input) {
         ? toPosixRelative(input.repoRoot, absoluteSource)
         : input.filePath.split(path.sep).join("/");
     const materializedRelativePath = `${SOURCE_REFERENCE_DIRECTORY}/${targetFileName}`;
-    const document = matching ?? {
+    const document = {
         role,
         name: requestedName,
         sourcePath: sourcePathForRecord,
@@ -189,28 +176,20 @@ export async function importPrdDocument(input) {
             : (existingManifest?.updatedAt ?? importedAt),
         documents,
     };
-    if (documentSetChanged)
-        await writeSourceManifest(paths.sourceDir, manifest);
+    await writeSourceManifest(paths.sourceDir, manifest);
     const taskConfig = await loadTaskConfig(input.repoRoot, input.taskId);
     const referenceDocs = [...(taskConfig.referenceDocs ?? [])];
-    const listedIndex = referenceDocs.findIndex((doc) => {
+    const alreadyListed = referenceDocs.some((doc) => {
         const absolute = path.isAbsolute(doc.path)
             ? doc.path
             : path.resolve(input.repoRoot, doc.path);
         return absolute === absoluteSource;
     });
-    // Keep original source paths as provenance, but point materialization at
-    // the chosen immutable filename so DAG generation cannot recreate duplicates.
-    const reference = {
-        name: path.basename(targetFileName, path.extname(targetFileName)),
-        path: sourcePathForRecord,
-    };
-    const configChanged = listedIndex < 0 || referenceDocs[listedIndex]?.name !== reference.name;
-    if (configChanged) {
-        if (listedIndex < 0)
-            referenceDocs.push(reference);
-        else
-            referenceDocs[listedIndex] = { ...referenceDocs[listedIndex], ...reference };
+    if (!alreadyListed) {
+        referenceDocs.push({
+            name: requestedName,
+            path: sourcePathForRecord,
+        });
         await writeTaskConfig(input.repoRoot, input.taskId, {
             ...taskConfig,
             referenceDocs,
@@ -219,15 +198,11 @@ export async function importPrdDocument(input) {
     // Managed contracts must bump revision after import-prd mutates manifest/task config.
     // Lazy import avoids circular init with contract/observe.
     const { refreshManagedContractAfterImport } = await import("./contract/import-revision.js");
-    const changed = documentSetChanged || configChanged;
-    if (changed) {
-        await refreshManagedContractAfterImport({
-            repoRoot: input.repoRoot,
-            taskId: input.taskId,
-        });
-    }
+    await refreshManagedContractAfterImport({
+        repoRoot: input.repoRoot,
+        taskId: input.taskId,
+    });
     return {
-        changed,
         taskId: input.taskId,
         sourcePath: sourcePathForRecord,
         materializedAbsolutePath: targetPath,
@@ -235,7 +210,7 @@ export async function importPrdDocument(input) {
         sha256: hash.sha256,
         bytes: hash.bytes,
         manifestPath: getSourceManifestPath(paths.sourceDir),
-        referenceDocs,
+        referenceDocs: alreadyListed ? referenceDocs : [...referenceDocs],
     };
 }
 async function sameHashIfExists(filePath, sha256) {

package/dist/task/source-state.js

@@ -0,0 +1 @@
+export { assertPlanFreshForImplement, markSpecCompleted, refreshSourceState, } from "./runtime.js";

package/dist/task/subagent-guidance.js

@@ -0,0 +1 @@
+export { resolvePiSubagentTools, resolveSubagentGuidance, shouldInjectSubagentGuidance, SUBAGENT_GUIDANCE, SUBAGENT_GUIDANCE_STANDARD, SUBAGENT_GUIDANCE_STRONG, } from "./runtime.js";

package/dist/worker/console/chat/assistant-content.js

@@ -115,30 +115,9 @@ export function splitFinalAssistantBlocks(blocks, options = {}) {
     if (lastProcessIndex === -1) {
         return { answerBlocks: displayable, processBlocks: [] };
     }
-    const trailing = displayable.slice(lastProcessIndex + 1);
-    if (trailing.length > 0) {
-        return {
-            answerBlocks: trailing,
-            processBlocks: displayable.slice(0, lastProcessIndex + 1),
-        };
-    }
-    // The stage ends on a non-text block (a tool call after the prose, or a final
-    // thinking block). Returning an empty answer here hid the whole reply inside
-    // the collapsed process subtree; keep the last prose block as the visible
-    // answer instead (2026-09-08).
-    let lastTextIndex = -1;
-    for (let i = displayable.length - 1; i >= 0; i--) {
-        if (isFinalAnswerBlock(displayable[i])) {
-            lastTextIndex = i;
-            break;
-        }
-    }
-    if (lastTextIndex === -1) {
-        return { answerBlocks: [], processBlocks: displayable };
-    }
     return {
-        answerBlocks: [displayable[lastTextIndex]],
-        processBlocks: displayable.filter((_block, index) => index !== lastTextIndex),
+        answerBlocks: displayable.slice(lastProcessIndex + 1),
+        processBlocks: displayable.slice(0, lastProcessIndex + 1),
     };
 }
 export function joinAssistantText(blocks) {

package/dist/worker/console/chat/explore-tools.js

@@ -71,10 +71,6 @@ export const SECRET_SCRUB_PATTERNS = [
         name: "private-key-block",
         re: /-----BEGIN (?:RSA |EC |OPENSSH |DSA |)PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |DSA |)PRIVATE KEY-----/g,
     },
-    {
-        name: "aimax-auth-token",
-        re: /\bAIMAX_AUTH_TOKEN=["']?[^\s"']+/g,
-    },
 ];
 /** Throw a typed explore error (kept as a value object so callers can read .code). */
 export class ExploreDeniedError extends Error {
@@ -93,10 +89,6 @@ export class ExploreDeniedError extends Error {
  */
 export function scrubSecrets(input) {
     let out = input;
-    const liveToken = process.env.AIMAX_AUTH_TOKEN;
-    if (liveToken && liveToken.length >= 8 && out.includes(liveToken)) {
-        out = out.split(liveToken).join("[REDACTED:aimax-auth-token]");
-    }
     const redactions = [];
     for (const { name, re } of SECRET_SCRUB_PATTERNS) {
         re.lastIndex = 0;
@@ -106,11 +98,6 @@ export function scrubSecrets(input) {
             redactions.push({ name, count: matches.length });
         }
     }
-    if (liveToken && liveToken.length >= 8 && input.includes(liveToken)) {
-        const existing = redactions.find((entry) => entry.name === "aimax-auth-token");
-        if (!existing)
-            redactions.push({ name: "aimax-auth-token", count: 1 });
-    }
     return { scrubbed: out, redactions };
 }
 /** True if a repo-relative path matches a sensitive-file denylist pattern. */