pi-usereq 0.10.0 → 0.12.0

package/src/core/prompt-command-runtime.ts

@@ -1,7 +1,7 @@
 /**
  * @file
- * @brief Implements prompt-command preflight and worktree orchestration.
- * @details Centralizes `req-<prompt>` repository validation, prompt-specific required-document checks, slash-command-owned worktree naming and lifecycle handling, session-backed cwd switching plus verification, persisted replacement-session context reuse for non-command lifecycle handlers, matched-success fast-forward merge finalization, and command-side abort cleanup. Runtime is dominated by git subprocess execution plus bounded filesystem and session-file metadata checks. Side effects include active-session replacement, worktree creation and deletion, branch merges, and filesystem reads and writes.
+ * @brief Implements bundled prompt-command preflight and worktree orchestration.
+ * @details Centralizes prompt-template-backed `req-<prompt>` repository validation, prompt-specific required-document checks, slash-command-owned worktree naming and lifecycle handling, reusable transcript-preservation plus session-restoration helpers, persisted replacement-session context reuse for non-command lifecycle handlers, matched-success stash-assisted fast-forward merge finalization, and command-side abort cleanup. Runtime is dominated by git subprocess execution plus bounded filesystem and session-file metadata checks. Side effects include active-session replacement, worktree creation and deletion, branch merges, stash-stack mutation, and filesystem reads and writes.
  */
 
 import fs from "node:fs";
@@ -19,10 +19,7 @@ import {
   logDebugPromptWorkflowEvent,
   type DebugWorkflowState,
 } from "./debug-runtime.js";
-import {
-  PROMPT_COMMAND_NAMES,
-  type PromptCommandName,
-} from "./prompt-command-catalog.js";
+import { type PromptCommandName } from "./prompt-command-catalog.js";
 import {
   isSameOrAncestorPath,
   normalizeRelativeDirContract,
@@ -421,6 +418,169 @@ function readPromptSessionFileCwd(sessionFile: string): string | undefined {
   return typeof headerCwd === "string" ? headerCwd : undefined;
 }
 
+/**
+ * @brief Reads one persisted session file as ordered parsed JSONL records.
+ * @details Loads the raw session file, preserves every non-empty serialized line verbatim, parses each line as one JSON object, and rejects unreadable or structurally invalid files so prompt-closure helpers can replay exact execution-session transcript records into the restored base session without reserialization drift. Runtime is O(n) in session-file size. No external state is mutated.
+ * @param[in] sessionFile {string} Absolute session-file path.
+ * @return {Array<{ rawLine: string; parsed: Record<string, unknown> }>} Parsed non-empty JSONL lines in file order.
+ * @throws {ReqError} Throws when the file cannot be read, when it contains no JSONL records, when any record is not a JSON object, or when the header record is missing.
+ */
+function readPromptSessionJsonLines(
+  sessionFile: string,
+): Array<{ rawLine: string; parsed: Record<string, unknown> }> {
+  const normalizedSessionFile = path.resolve(sessionFile);
+  let raw: string;
+  try {
+    raw = fs.readFileSync(normalizedSessionFile, "utf8");
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new ReqError(
+      `ERROR: Unable to read session file ${normalizedSessionFile}: ${errorMessage}.`,
+      1,
+    );
+  }
+  const parsedLines: Array<{ rawLine: string; parsed: Record<string, unknown> }> = [];
+  for (const [index, rawLine] of raw.split(/\r?\n/u).entries()) {
+    if (rawLine.trim() === "") {
+      continue;
+    }
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(rawLine);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new ReqError(
+        `ERROR: Unable to parse session file ${normalizedSessionFile} line ${index + 1}: ${errorMessage}.`,
+        1,
+      );
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new ReqError(
+        `ERROR: Session file ${normalizedSessionFile} line ${index + 1} is not a JSON object.`,
+        1,
+      );
+    }
+    parsedLines.push({ rawLine, parsed: parsed as Record<string, unknown> });
+  }
+  if (parsedLines.length === 0) {
+    throw new ReqError(`ERROR: Session file ${normalizedSessionFile} is empty.`, 1);
+  }
+  if (parsedLines[0]?.parsed.type !== "session") {
+    throw new ReqError(
+      `ERROR: Session file ${normalizedSessionFile} is missing a valid session header.`,
+      1,
+    );
+  }
+  return parsedLines;
+}
+
+/**
+ * @brief Copies successful execution-session transcript records into the restored base session file.
+ * @details Reads the execution session JSONL file, preserves the original base-session header when it already exists, materializes a restored base-session header when the reserved original session file is still pending persistence, appends any execution-session records missing from the original session in original execution order, and re-reads the restored file to verify both `base-path` cwd and copied entry identifiers. Runtime is O(n) in combined session-file size. Side effects include session-file creation or append operations for the restored base session.
+ * @param[in] plan {PromptCommandExecutionPlan} Prompt execution plan whose original and execution session files must be synchronized.
+ * @return {void} No return value.
+ * @throws {ReqError} Throws when either session file is unreadable or when appended execution records are not persisted to the original session file.
+ * @satisfies REQ-208, REQ-307
+ */
+export function preservePromptCommandExecutionTranscript(plan: PromptCommandExecutionPlan): void {
+  const normalizedOriginalSessionFile = path.resolve(plan.originalSessionFile);
+  const normalizedExecutionSessionFile = path.resolve(plan.executionSessionFile);
+  if (normalizedOriginalSessionFile === normalizedExecutionSessionFile) {
+    return;
+  }
+  const executionLines = readPromptSessionJsonLines(normalizedExecutionSessionFile);
+  const executionEntryIds = executionLines
+    .slice(1)
+    .map((line) => line.parsed.id)
+    .filter((entryId): entryId is string => typeof entryId === "string" && entryId !== "");
+  if (!fs.existsSync(normalizedOriginalSessionFile)) {
+    const rewrittenHeader: Record<string, unknown> = {
+      ...executionLines[0]!.parsed,
+      cwd: plan.basePath,
+    };
+    if (
+      typeof rewrittenHeader.parentSession === "string"
+      && path.resolve(rewrittenHeader.parentSession) === normalizedOriginalSessionFile
+    ) {
+      delete rewrittenHeader.parentSession;
+    }
+    try {
+      fs.mkdirSync(path.dirname(normalizedOriginalSessionFile), { recursive: true });
+      const serializedLines = [
+        JSON.stringify(rewrittenHeader),
+        ...executionLines.slice(1).map((line) => line.rawLine),
+      ];
+      fs.writeFileSync(
+        normalizedOriginalSessionFile,
+        `${serializedLines.join("\n")}\n`,
+        "utf8",
+      );
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new ReqError(
+        `ERROR: Unable to materialize restored session transcript in ${normalizedOriginalSessionFile}: ${errorMessage}.`,
+        1,
+      );
+    }
+  } else {
+    const originalLines = readPromptSessionJsonLines(normalizedOriginalSessionFile);
+    const existingEntryIds = new Set<string>();
+    for (const line of originalLines.slice(1)) {
+      const entryId = line.parsed.id;
+      if (typeof entryId === "string" && entryId !== "") {
+        existingEntryIds.add(entryId);
+      }
+    }
+    const missingExecutionLines = executionLines.slice(1).filter((line) => {
+      const entryId = line.parsed.id;
+      return typeof entryId === "string"
+        && entryId !== ""
+        && !existingEntryIds.has(entryId);
+    });
+    if (missingExecutionLines.length > 0) {
+      const originalRaw = fs.readFileSync(normalizedOriginalSessionFile, "utf8");
+      const leadingSeparator = originalRaw === "" || originalRaw.endsWith("\n") ? "" : "\n";
+      try {
+        fs.appendFileSync(
+          normalizedOriginalSessionFile,
+          `${leadingSeparator}${missingExecutionLines.map((line) => line.rawLine).join("\n")}\n`,
+          "utf8",
+        );
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new ReqError(
+          `ERROR: Unable to preserve execution transcript in ${normalizedOriginalSessionFile}: ${errorMessage}.`,
+          1,
+        );
+      }
+    }
+  }
+  const synchronizedSessionCwd = readPromptSessionFileCwd(normalizedOriginalSessionFile);
+  if (
+    typeof synchronizedSessionCwd !== "string"
+    || path.resolve(synchronizedSessionCwd) !== path.resolve(plan.basePath)
+  ) {
+    throw new ReqError(
+      `ERROR: Restored session transcript expected cwd ${path.resolve(plan.basePath)} but observed ${synchronizedSessionCwd ?? "missing"}.`,
+      1,
+    );
+  }
+  const synchronizedEntryIds = new Set<string>();
+  for (const line of readPromptSessionJsonLines(normalizedOriginalSessionFile).slice(1)) {
+    const entryId = line.parsed.id;
+    if (typeof entryId === "string" && entryId !== "") {
+      synchronizedEntryIds.add(entryId);
+    }
+  }
+  const missingSynchronizedIds = executionEntryIds.filter((entryId) => !synchronizedEntryIds.has(entryId));
+  if (missingSynchronizedIds.length > 0) {
+    throw new ReqError(
+      `ERROR: Unable to verify execution transcript preservation for ${normalizedOriginalSessionFile}: missing entries ${missingSynchronizedIds.join(", ")}.`,
+      1,
+    );
+  }
+}
+
 /**
  * @brief Verifies that the active session file and cwd surfaces match one expected prompt-orchestration target.
  * @details Re-reads the persisted session-file header when present plus the host `process.cwd()` and throws on the first mismatch so prompt commands abort before prompt dispatch or prompt-end handling whenever session switching leaves execution attached to the wrong cwd. A missing persisted session file is treated as a non-fatal lazy-persistence state because pi's `SessionManager` writes session files on first assistant flush rather than eagerly during `ctx.switchSession(sessionPath)`; when the file is absent, pi aligns its internal session cwd to the live `process.cwd()`, so verifying `process.cwd()` alone is authoritative in that state. Reads of `ctx.cwd`, `ctx.sessionManager.getCwd()`, and `ctx.sessionManager.getSessionFile()` are advisory only because the pi `ctx.switchSession(sessionPath)` SDK contract does not mutate the handler-scoped `ctx` object, so those probes stay bound to the pre-switch session and a divergent value alone never triggers abort; they only surface a mismatch when they disagree with both the persisted header cwd and the live `process.cwd()`. Runtime is O(p) in aggregate path length plus one session-file header read. No external state is mutated.
@@ -666,9 +826,6 @@ const PROMPT_REQUIRED_DOCS: Record<PromptCommandName, readonly PromptRequiredDoc
     { fileName: "WORKFLOW.md", promptCommand: "/req-workflow" },
     { fileName: "REFERENCES.md", promptCommand: "/req-references" },
   ],
-  references: [
-    { fileName: "REQUIREMENTS.md", promptCommand: "/req-write" },
-  ],
   renumber: [
     { fileName: "REQUIREMENTS.md", promptCommand: "/req-write" },
     { fileName: "WORKFLOW.md", promptCommand: "/req-workflow" },
@@ -692,6 +849,166 @@ function runCapture(command: string[], cwd: string): ReturnType<typeof spawnSync
   });
 }
 
+/**
+ * @brief Lists tracked `base-path` status rows that require stash-assisted merge handling.
+ * @details Executes `git status --porcelain`, retains only tracked rows whose index or worktree slot reports a change, and excludes untracked or ignored rows because the required `git stash` command does not preserve them. Runtime is dominated by one git subprocess plus O(n) parsing in status-line count. Side effects include process spawning.
+ * @param[in] basePath {string} Restored project base path.
+ * @return {string[]} Tracked status rows requiring stash-assisted merge handling.
+ * @throws {ReqError} Throws when git status cannot be read from `basePath`.
+ * @satisfies REQ-291
+ */
+function listPromptTrackedBasePathChanges(basePath: string): string[] {
+  const statusResult = runCapture(["git", "status", "--porcelain"], basePath);
+  if (statusResult.error || statusResult.status !== 0) {
+    throw new ReqError("ERROR: Unable to inspect base-path changes before merge.", 1);
+  }
+  return statusResult.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .filter((line) => line !== "")
+    .filter((line) => {
+      const statusCode = line.slice(0, 2);
+      if (statusCode === "??" || statusCode === "!!") {
+        return false;
+      }
+      const indexStatus = statusCode[0] ?? " ";
+      const worktreeStatus = statusCode[1] ?? " ";
+      return indexStatus !== " " || worktreeStatus !== " ";
+    });
+}
+
+/**
+ * @brief Executes the successful-closure merge sequence from restored `base-path`.
+ * @details Detects tracked staged or unstaged `base-path` changes, wraps the existing fast-forward merge in `git stash` and `git stash pop` when required, preserves the direct merge path when no tracked changes exist, emits a warning-only result after successful local-change restoration, and writes one merge-finalization debug entry when enabled. Runtime is dominated by up to four git subprocesses plus O(n) status parsing. Side effects include stash-stack mutation, branch merge attempts, and optional debug-log writes.
+ * @param[in] plan {PromptCommandExecutionPlan} Prompt execution plan whose branch should be merged.
+ * @param[in] debugOptions {PromptCommandDebugOptions | undefined} Optional prompt debug logging context.
+ * @return {{ mergeAttempted: boolean; mergeSucceeded: boolean; errorMessage?: string; warningMessage?: string }} Merge-attempt facts plus optional warning text.
+ * @satisfies REQ-208, REQ-245, REQ-291, REQ-292
+ */
+function finalizePromptCommandMerge(
+  plan: PromptCommandExecutionPlan,
+  debugOptions?: PromptCommandDebugOptions,
+): {
+  mergeAttempted: boolean;
+  mergeSucceeded: boolean;
+  errorMessage?: string;
+  warningMessage?: string;
+} {
+  const worktreeDir = plan.worktreeDir ?? plan.branchName;
+  const mergeLogInput = {
+    worktree_dir: worktreeDir,
+    branch_name: plan.branchName,
+  };
+  let trackedStatusLines: string[];
+  try {
+    trackedStatusLines = listPromptTrackedBasePathChanges(plan.basePath);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (debugOptions) {
+      logDebugPromptEvent(
+        plan.basePath,
+        debugOptions.config,
+        debugOptions.workflowState,
+        plan.promptName,
+        "merge",
+        mergeLogInput,
+        {
+          success: false,
+          merge_attempted: false,
+          error: errorMessage,
+        },
+        true,
+      );
+    }
+    return {
+      mergeAttempted: false,
+      mergeSucceeded: false,
+      errorMessage,
+    };
+  }
+  const usedStash = trackedStatusLines.length > 0;
+  let stashStatus: number | null | undefined;
+  if (usedStash) {
+    const stashResult = runCapture(["git", "stash"], plan.basePath);
+    stashStatus = stashResult.status;
+    if (stashResult.error || stashResult.status !== 0) {
+      const errorMessage = `ERROR: Unable to stash base-path changes before merge for worktree ${worktreeDir}.`;
+      if (debugOptions) {
+        logDebugPromptEvent(
+          plan.basePath,
+          debugOptions.config,
+          debugOptions.workflowState,
+          plan.promptName,
+          "merge",
+          {
+            ...mergeLogInput,
+            used_stash: true,
+            tracked_change_count: trackedStatusLines.length,
+          },
+          {
+            success: false,
+            merge_attempted: false,
+            error: errorMessage,
+            stash_status: stashStatus,
+          },
+          true,
+        );
+      }
+      return {
+        mergeAttempted: false,
+        mergeSucceeded: false,
+        errorMessage,
+      };
+    }
+  }
+  const mergeResult = runCapture(
+    ["git", "merge", "--ff-only", plan.branchName],
+    plan.basePath,
+  );
+  const mergeSucceeded = !mergeResult.error && mergeResult.status === 0;
+  const errorMessage = mergeSucceeded
+    ? undefined
+    : `ERROR: Fast-forward merge failed for worktree ${worktreeDir}.`;
+  let stashPopStatus: number | null | undefined;
+  let warningMessage: string | undefined;
+  if (usedStash) {
+    const stashPopResult = runCapture(["git", "stash", "pop"], plan.basePath);
+    stashPopStatus = stashPopResult.status;
+    if (mergeSucceeded) {
+      warningMessage = "WARNING: Restored base-path changes after merge; base-path is not clean.";
+    }
+  }
+  if (debugOptions) {
+    logDebugPromptEvent(
+      plan.basePath,
+      debugOptions.config,
+      debugOptions.workflowState,
+      plan.promptName,
+      "merge",
+      {
+        ...mergeLogInput,
+        used_stash: usedStash,
+        tracked_change_count: trackedStatusLines.length,
+      },
+      {
+        success: mergeSucceeded,
+        merge_attempted: true,
+        error: errorMessage,
+        warning: warningMessage,
+        stash_status: stashStatus,
+        stash_pop_status: stashPopStatus,
+      },
+      !mergeSucceeded,
+    );
+  }
+  return {
+    mergeAttempted: true,
+    mergeSucceeded,
+    errorMessage,
+    warningMessage,
+  };
+}
+
 /**
  * @brief Stores or clears the prompt-command post-create test hook.
  * @details Enables deterministic simulation of post-create worktree verification failures without altering production control flow. Runtime is O(1). Side effect: mutates module-local test state.
@@ -787,15 +1104,15 @@ function throwPromptGitStatusError(): never {
 }
 
 /**
- * @brief Runs prompt-command-owned git validation and returns the runtime git root.
- * @details Validates work-tree membership, porcelain cleanliness, and symbolic or detached `HEAD` presence without invoking extension custom-tool executors. Runtime is dominated by git subprocess execution. Side effects include process spawning.
+ * @brief Runs slash-command-owned git validation and returns the runtime git root.
+ * @details Validates work-tree membership, porcelain cleanliness, and symbolic or detached `HEAD` presence for bundled prompt commands and `req-references` without invoking extension custom-tool executors. Runtime is dominated by git subprocess execution. Side effects include process spawning.
  * @param[in] projectBase {string} Absolute current project base.
  * @param[in] config {UseReqConfig | undefined} Optional effective project configuration used to ignore extension-owned debug-log artifacts.
  * @return {string} Absolute runtime git root.
  * @throws {ReqError} Throws the canonical prompt-command git-preflight error on any validation failure.
  * @satisfies REQ-200, REQ-220
  */
-function validatePromptGitState(projectBase: string, config?: UseReqConfig): string {
+export function validatePromptGitState(projectBase: string, config?: UseReqConfig): string {
   const gitPath = resolveRuntimeGitPath(projectBase);
   if (!gitPath) {
     throwPromptGitStatusError();
@@ -1117,9 +1434,9 @@ function createPromptWorktree(
  * @param[in] debugOptions {PromptCommandDebugOptions | undefined} Optional prompt debug logging context.
  * @return {void} No return value.
  * @throws {ReqError} Throws when cleanup cannot remove the worktree and branch fully.
- * @satisfies REQ-208, REQ-220, REQ-245
+ * @satisfies REQ-208, REQ-220, REQ-245, REQ-309
  */
-function deletePromptWorktree(
+export function deletePromptWorktree(
   basePath: string,
   worktreeDir: string,
   worktreeRootPath: string,
@@ -1528,12 +1845,12 @@ export async function abortPromptCommandExecution(
 
 /**
  * @brief Finalizes one matched successful worktree-backed prompt execution.
- * @details Re-verifies persisted execution-session metadata plus worktree artifacts, restores the original session-backed `base-path`, fast-forward merges the successful worktree branch from `base-path`, deletes the worktree after merge success, and preserves the restored base session across closure failures. Closure intentionally treats `base-path` restoration as authoritative even when pi CLI has already started end-of-session session replacement or other housekeeping that moved the live runtime away from `worktree-path`. Runtime is dominated by session switching plus git subprocess execution. Side effects include active-session replacement, branch merges, worktree deletion, and optional debug-log writes.
+ * @details Re-verifies persisted execution-session metadata plus worktree artifacts, copies any execution-session transcript records missing from the original session file, restores the original session-backed `base-path`, executes the stash-assisted fast-forward merge sequence from `base-path`, deletes the worktree after merge success, and preserves the restored base session across closure failures. Closure intentionally treats `base-path` restoration as authoritative even when pi CLI has already started end-of-session session replacement or other housekeeping that moved the live runtime away from `worktree-path`. Runtime is dominated by session switching plus git subprocess execution. Side effects include session-file appends, active-session replacement, branch merges, stash-stack mutation, worktree deletion, and optional debug-log writes.
  * @param[in] plan {PromptCommandExecutionPlan} Prompt execution plan.
  * @param[in] ctx {PromptCommandSessionContext | undefined} Optional prompt-command context.
  * @param[in] debugOptions {PromptCommandDebugOptions | undefined} Optional prompt debug logging context.
- * @return {Promise<{ mergeAttempted: boolean; mergeSucceeded: boolean; cleanupSucceeded: boolean; errorMessage?: string; activeContext?: PromptCommandSessionContext }>} Finalization facts plus the last valid active prompt-command context.
- * @satisfies REQ-208, REQ-209, REQ-220, REQ-245, REQ-282
+ * @return {Promise<{ mergeAttempted: boolean; mergeSucceeded: boolean; cleanupSucceeded: boolean; errorMessage?: string; warningMessage?: string; activeContext?: PromptCommandSessionContext }>} Finalization facts plus the last valid active prompt-command context.
+ * @satisfies REQ-208, REQ-209, REQ-220, REQ-245, REQ-282, REQ-291, REQ-292
  */
 export async function finalizePromptCommandExecution(
   plan: PromptCommandExecutionPlan,
@@ -1544,12 +1861,16 @@ export async function finalizePromptCommandExecution(
   mergeSucceeded: boolean;
   cleanupSucceeded: boolean;
   errorMessage?: string;
+  warningMessage?: string;
   activeContext?: PromptCommandSessionContext;
 }> {
   let activeContext = ctx;
   let verificationErrorMessage: string | undefined;
   try {
     verifyPromptCommandClosureArtifacts(plan);
+    if (plan.worktreePath && plan.worktreeDir && plan.worktreeRootPath) {
+      preservePromptCommandExecutionTranscript(plan);
+    }
   } catch (error) {
     verificationErrorMessage = error instanceof Error ? error.message : String(error);
   }
@@ -1583,32 +1904,14 @@ export async function finalizePromptCommandExecution(
       activeContext,
     };
   }
-  const mergeResult = runCapture(
-    ["git", "merge", "--ff-only", plan.branchName],
-    plan.basePath,
-  );
-  const mergeSucceeded = !mergeResult.error && mergeResult.status === 0;
-  const errorMessage = mergeSucceeded
-    ? undefined
-    : `ERROR: Fast-forward merge failed for worktree ${plan.worktreeDir}.`;
-  if (debugOptions) {
-    logDebugPromptEvent(
-      plan.basePath,
-      debugOptions.config,
-      debugOptions.workflowState,
-      plan.promptName,
-      "merge",
-      { worktree_dir: plan.worktreeDir, branch_name: plan.branchName },
-      { success: mergeSucceeded, error: errorMessage },
-      !mergeSucceeded,
-    );
-  }
-  if (!mergeSucceeded) {
+  const mergeFinalization = finalizePromptCommandMerge(plan, debugOptions);
+  if (!mergeFinalization.mergeSucceeded) {
     return {
-      mergeAttempted: true,
+      mergeAttempted: mergeFinalization.mergeAttempted,
       mergeSucceeded: false,
       cleanupSucceeded: true,
-      errorMessage,
+      errorMessage: mergeFinalization.errorMessage,
+      warningMessage: mergeFinalization.warningMessage,
       activeContext,
     };
   }
@@ -1622,17 +1925,19 @@ export async function finalizePromptCommandExecution(
     );
   } catch {
     return {
-      mergeAttempted: true,
+      mergeAttempted: mergeFinalization.mergeAttempted,
       mergeSucceeded: true,
       cleanupSucceeded: false,
       errorMessage: `ERROR: Unable to remove worktree or branch ${plan.worktreeDir}.`,
+      warningMessage: mergeFinalization.warningMessage,
       activeContext,
     };
   }
   return {
-    mergeAttempted: true,
+    mergeAttempted: mergeFinalization.mergeAttempted,
     mergeSucceeded: true,
     cleanupSucceeded: true,
+    warningMessage: mergeFinalization.warningMessage,
     activeContext,
   };
 }

package/src/core/prompts.ts

@@ -22,14 +22,12 @@ import { readBundledInstruction, readBundledPrompt } from "./resources.js";
 const TOOL_REFERENCE_REPLACEMENTS: Array<[RegExp, string]> = [
   [/`req --find`/g, "`search` tool"],
   [/`req --files-find`/g, "`files-search` tool"],
-  [/`req --references`/g, "`references` tool"],
   [/`req --compress`/g, "`compress` tool"],
   [/`req --tokens`/g, "`tokens` tool"],
   [/`req --static-check`/g, "`static-check` tool"],
   [/`req --files-static-check`/g, "`files-static-check` tool"],
   [/\breq --find\b/g, "search tool"],
   [/\breq --files-find\b/g, "files-search tool"],
-  [/\breq --references\b/g, "references tool"],
   [/\breq --compress\b/g, "compress tool"],
   [/\breq --tokens\b/g, "tokens tool"],
   [/\breq --static-check\b/g, "static-check tool"],