pi-usereq 0.7.0 → 0.11.0

package/src/core/agent-tool-json.ts

@@ -1,12 +1,15 @@
 /**
  * @file
- * @brief Builds structured agent-tool JSON payloads for path, git, docs, worktree, and static-check tools.
- * @details Converts extension-tool execution state into deterministic JSON-first payloads optimized for direct LLM traversal. The module normalizes execution metadata, path facts, required-doc status, worktree mutation facts, and static-check file-selection facts without depending on presentation-oriented text. Runtime is O(F) in the number of described files plus path normalization cost. Side effects are limited to filesystem reads.
+ * @brief Builds shared agent-tool result helpers plus static-check payloads.
+ * @details Converts extension-tool execution state into deterministic monolithic content blocks, minimal execution metadata, and static-check file-selection facts. Runtime is O(F) in the number of described files plus path normalization cost. Side effects are limited to filesystem reads.
  */
 
 import fs from "node:fs";
 import path from "node:path";
-import type { StaticCheckEntry } from "./config.js";
+import {
+  getActiveStaticCheckEntries,
+  type StaticCheckLanguageConfig,
+} from "./config.js";
 import { ReqError } from "./errors.js";
 import { STATIC_CHECK_EXT_TO_LANG } from "./static-check.js";
 import type { ToolResult } from "./tool-runner.js";
@@ -30,80 +33,6 @@ export interface StructuredToolExecuteResult<T> {
   details: T;
 }
 
-/**
- * @brief Describes the structured payload returned by path-query tools.
- * @details Exposes only the resolved path facts that can differ at runtime plus residual execution diagnostics, omitting caller-known request echoes and duplicated runtime-path inventories. The interface is compile-time only and introduces no runtime cost.
- */
-export interface PathQueryToolPayload {
-  result: {
-    path_value: string;
-    path_present: boolean;
-  };
-  execution: ToolExecutionSection;
-}
-
-/**
- * @brief Describes the structured payload returned by `git-check`.
- * @details Exposes only the runtime git-path presence fact plus aggregate repository validation status, omitting intermediate request metadata whose semantics already live in the tool registration. The interface is compile-time only and introduces no runtime cost.
- */
-export interface GitCheckToolPayload {
-  result: {
-    git_path_present: boolean;
-    status: "clean" | "error";
-    error_message?: string;
-  };
-  execution: ToolExecutionSection;
-}
-
-/**
- * @brief Describes one canonical-doc status record returned by `docs-check`.
- * @details Stores the canonical path, remediation prompt command, and presence status while omitting redundant filesystem probe fields already summarized by the status value. The interface is compile-time only and introduces no runtime cost.
- */
-export interface DocsCheckFileRecord {
-  file_name: string;
-  canonical_path: string;
-  prompt_command: string;
-  status: "present" | "missing";
-}
-
-/**
- * @brief Describes the structured payload returned by `docs-check`.
- * @details Exposes per-document presence facts and remediation commands plus residual execution diagnostics, omitting static request metadata that can be inferred from the tool registration and caller context. The interface is compile-time only and introduces no runtime cost.
- */
-export interface DocsCheckToolPayload {
-  summary: {
-    present_file_count: number;
-    missing_file_count: number;
-  };
-  files: DocsCheckFileRecord[];
-  execution: ToolExecutionSection;
-}
-
-/**
- * @brief Describes the structured payload returned by `git-wt-name`.
- * @details Exposes only the generated worktree name plus residual execution diagnostics, omitting the static normative format string because it already belongs in registration metadata. The interface is compile-time only and introduces no runtime cost.
- */
-export interface WorktreeNameToolPayload {
-  result: {
-    worktree_name?: string;
-    error_message?: string;
-  };
-  execution: ToolExecutionSection;
-}
-
-/**
- * @brief Describes the structured payload returned by worktree mutation tools.
- * @details Exposes only the exact worktree name and derived path that can vary per invocation plus residual execution diagnostics, omitting static operation descriptors and duplicated branch-name fields. The interface is compile-time only and introduces no runtime cost.
- */
-export interface WorktreeMutationToolPayload {
-  result: {
-    worktree_name: string;
-    worktree_path: string;
-    error_message?: string;
-  };
-  execution: ToolExecutionSection;
-}
-
 /**
  * @brief Describes one file-selection record inside a static-check payload.
  * @details Exposes canonical path, detected language, configured checker modules, and stable selection status without echoing caller inputs or redundant filesystem probe fields. The interface is compile-time only and introduces no runtime cost.
@@ -203,202 +132,87 @@ export function buildToolExecutionSection(result: ToolResult): ToolExecutionSect
 }
 
 /**
- * @brief Converts one `ReqError` into a synthetic `ToolResult` for structured payload emission.
- * @details Preserves the numeric exit code and message in stderr so agent tools can return deterministic JSON even when the underlying runner fails. Non-`ReqError` values are rethrown. Runtime is O(1). No external state is mutated.
- * @param[in] error {unknown} Thrown value captured from a runner.
- * @return {ToolResult} Synthetic tool result with empty stdout.
- * @throws {unknown} Rethrows non-`ReqError` failures unchanged.
+ * @brief Selects the monolithic tool text exposed to the LLM-facing content channel.
+ * @details Prefers stdout so successful tool payloads preserve the primary formatter output verbatim, and falls back to stderr when the command failed before producing stdout. Runtime is O(n) in output length. No external state is mutated.
+ * @param[in] result {ToolResult} Raw tool result.
+ * @return {string} Monolithic text payload written to `content[0].text`.
  */
-export function normalizeToolFailure(error: unknown): ToolResult {
-  if (error instanceof ReqError) {
-    return {
-      stdout: "",
-      stderr: error.message,
-      code: error.code,
-    };
+function selectMonolithicToolText(result: ToolResult): string {
+  const stdoutText = result.stdout.trimEnd();
+  if (stdoutText !== "") {
+    return stdoutText;
   }
-  throw error;
-}
-
-/**
- * @brief Builds the structured payload returned by `git-path` or `get-base-path`.
- * @details Exposes only the resolved runtime path value plus residual execution metadata, omitting request echoes and duplicated runtime-path inventories from the runtime payload. Runtime is O(p) in path length. No external state is mutated.
- * @param[in] toolName {"git-path" | "get-base-path"} Target tool name.
- * @param[in] workingDirectoryPath {string} Caller working directory.
- * @param[in] projectBasePath {string} Resolved project base path.
- * @param[in] resolvedPath {string} Resolved config path value.
- * @param[in] execution {ToolExecutionSection} Normalized execution metadata.
- * @return {PathQueryToolPayload} Structured path-query payload.
- */
-export function buildPathQueryToolPayload(
-  toolName: "git-path" | "get-base-path",
-  workingDirectoryPath: string,
-  projectBasePath: string,
-  resolvedPath: string,
-  execution: ToolExecutionSection,
-): PathQueryToolPayload {
-  void toolName;
-  void workingDirectoryPath;
-  void projectBasePath;
-  return {
-    result: {
-      path_value: resolvedPath,
-      path_present: resolvedPath !== "",
-    },
-    execution,
-  };
+  return result.stderr.trimEnd();
 }
 
 /**
- * @brief Builds the structured payload returned by `git-check`.
- * @details Encodes runtime git-path presence plus aggregate clean-versus-error status while preserving raw diagnostics under execution. Runtime is O(p) in path length. No external state is mutated.
- * @param[in] projectBasePath {string} Resolved project base path.
- * @param[in] configuredGitPath {string | undefined} Runtime git root path.
- * @param[in] execution {ToolExecutionSection} Normalized execution metadata.
- * @return {GitCheckToolPayload} Structured git-check payload.
+ * @brief Builds the minimal execute wrapper used by monolithic agent-tool outputs.
+ * @details Writes exactly one LLM-facing text block to `content[0].text` and preserves only normalized execution metadata in `details.execution`. Runtime is O(n) in output length. No external state is mutated.
+ * @param[in] result {ToolResult} Raw tool result.
+ * @return {StructuredToolExecuteResult<{ execution: ToolExecutionSection }>} Monolithic execute wrapper.
  */
-export function buildGitCheckToolPayload(
-  projectBasePath: string,
-  configuredGitPath: string | undefined,
-  execution: ToolExecutionSection,
-): GitCheckToolPayload {
-  void projectBasePath;
-  const errorMessage = execution.stderr_lines?.[0];
+export function buildMonolithicToolExecuteResult(
+  result: ToolResult,
+): StructuredToolExecuteResult<{ execution: ToolExecutionSection }> {
   return {
-    result: {
-      git_path_present: Boolean(configuredGitPath),
-      status: execution.code === 0 ? "clean" : "error",
-      error_message: execution.code === 0 ? undefined : errorMessage,
+    content: [{ type: "text", text: selectMonolithicToolText(result) }],
+    details: {
+      execution: buildToolExecutionSection(result),
     },
-    execution,
   };
 }
 
 /**
- * @brief Builds the structured payload returned by `docs-check`.
- * @details Enumerates required canonical documents, binds each missing file to its remediation prompt command, and emits summary counts plus residual execution diagnostics while omitting static request metadata. Runtime is O(k) in required file count plus filesystem reads. Side effects are limited to filesystem reads.
- * @param[in] projectBasePath {string} Resolved project base path.
- * @param[in] docsDirPath {string} Configured docs directory relative to the project base.
- * @return {DocsCheckToolPayload} Structured docs-check payload.
+ * @brief Converts one runner failure into a synthetic `ToolResult`.
+ * @details Preserves numeric exit codes for `ReqError`, converts generic `Error` instances into exit code `1` with stderr text, and falls back to string coercion for other thrown values so agent tools can return deterministic execution metadata. Runtime is O(1). No external state is mutated.
+ * @param[in] error {unknown} Thrown value captured from a runner.
+ * @return {ToolResult} Synthetic tool result with empty stdout.
  */
-export function buildDocsCheckToolPayload(
-  projectBasePath: string,
-  docsDirPath: string,
-): DocsCheckToolPayload {
-  const normalizedProjectBasePath = path.resolve(projectBasePath);
-  const normalizedDocsRootPath = path.join(normalizedProjectBasePath, docsDirPath.replace(/[/\\]+$/, ""));
-  const files: DocsCheckFileRecord[] = [
-    ["REQUIREMENTS.md", "/req-write"],
-    ["WORKFLOW.md", "/req-workflow"],
-    ["REFERENCES.md", "/req-references"],
-  ].map(([fileName, promptCommand]) => {
-    const absolutePath = path.join(normalizedDocsRootPath, fileName);
-    const exists = fs.existsSync(absolutePath);
-    const isFile = exists && fs.statSync(absolutePath).isFile();
+export function normalizeToolFailure(error: unknown): ToolResult {
+  if (error instanceof ReqError) {
     return {
-      file_name: fileName,
-      canonical_path: canonicalizeToolPath(normalizedProjectBasePath, absolutePath),
-      prompt_command: promptCommand,
-      status: isFile ? "present" : "missing",
+      stdout: "",
+      stderr: error.message,
+      code: error.code,
     };
-  });
-  const missingFiles = files.filter((file) => file.status === "missing");
-  const execution = buildToolExecutionSection({
-    stdout: "",
-    stderr: missingFiles
-      .map((file) => `missing: ${file.canonical_path}: generate with ${file.prompt_command}`)
-      .join("\n"),
-    code: missingFiles.length === 0 ? 0 : 1,
-  });
-  return {
-    summary: {
-      present_file_count: files.length - missingFiles.length,
-      missing_file_count: missingFiles.length,
-    },
-    files,
-    execution,
-  };
-}
-
-/**
- * @brief Builds the structured payload returned by `git-wt-name`.
- * @details Preserves only the generated worktree name and error diagnostics, leaving the static naming format in registration metadata instead of the runtime payload. Runtime is O(n) in output size. No external state is mutated.
- * @param[in] projectBasePath {string} Resolved project base path.
- * @param[in] configuredGitPath {string | undefined} Runtime git root path.
- * @param[in] execution {ToolExecutionSection} Normalized execution metadata.
- * @return {WorktreeNameToolPayload} Structured worktree-name payload.
- */
-export function buildWorktreeNameToolPayload(
-  projectBasePath: string,
-  configuredGitPath: string | undefined,
-  execution: ToolExecutionSection,
-): WorktreeNameToolPayload {
-  void projectBasePath;
-  void configuredGitPath;
-  const worktreeName = execution.stdout_lines?.[0];
-  return {
-    result: {
-      worktree_name: worktreeName,
-      error_message: execution.code === 0 ? undefined : execution.stderr_lines?.[0],
-    },
-    execution,
-  };
-}
-
-/**
- * @brief Builds the structured payload returned by `git-wt-create` or `git-wt-delete`.
- * @details Exposes only the exact worktree name, derived worktree path, and error diagnostics, omitting static operation and branch-name echoes from the runtime payload. Runtime is O(p) in path length. No external state is mutated.
- * @param[in] toolName {"git-wt-create" | "git-wt-delete"} Target tool name.
- * @param[in] projectBasePath {string} Resolved project base path.
- * @param[in] configuredGitPath {string | undefined} Runtime git root path.
- * @param[in] worktreeName {string} Exact requested worktree name.
- * @param[in] execution {ToolExecutionSection} Normalized execution metadata.
- * @return {WorktreeMutationToolPayload} Structured worktree mutation payload.
- */
-export function buildWorktreeMutationToolPayload(
-  toolName: "git-wt-create" | "git-wt-delete",
-  projectBasePath: string,
-  configuredGitPath: string | undefined,
-  worktreeName: string,
-  execution: ToolExecutionSection,
-): WorktreeMutationToolPayload {
-  void toolName;
-  void projectBasePath;
-  const gitRoot = configuredGitPath ? path.resolve(configuredGitPath) : "";
-  const worktreePath = gitRoot === ""
-    ? ""
-    : path.join(path.dirname(gitRoot), worktreeName).split(path.sep).join("/");
+  }
+  if (error instanceof Error) {
+    return {
+      stdout: "",
+      stderr: error.message,
+      code: 1,
+    };
+  }
   return {
-    result: {
-      worktree_name: worktreeName,
-      worktree_path: worktreePath,
-      error_message: execution.code === 0 ? undefined : execution.stderr_lines?.[0],
-    },
-    execution,
+    stdout: "",
+    stderr: String(error),
+    code: 1,
   };
 }
 
 /**
  * @brief Builds one static-check file-selection record.
- * @details Resolves filesystem status, detects the configured language by file extension, and emits the configured checker modules plus a stable selection status without echoing caller inputs or redundant filesystem facts. Runtime is O(p + c) in path length plus configured checker count. Side effects are limited to filesystem reads.
+ * @details Resolves filesystem status, detects the configured language by file extension, derives the active checker modules after per-language enable gating, and emits a stable selection status without echoing caller inputs or redundant filesystem facts. Runtime is O(p + c) in path length plus configured checker count. Side effects are limited to filesystem reads.
  * @param[in] inputPath {string} Caller-supplied file path.
  * @param[in] requestIndex {number} Zero-based request position.
  * @param[in] projectBasePath {string} Resolved project base path.
- * @param[in] staticCheckConfig {Record<string, StaticCheckEntry[]>} Effective static-check configuration.
+ * @param[in] staticCheckConfig {Record<string, StaticCheckLanguageConfig>} Effective static-check configuration.
  * @return {StaticCheckFileRecord} Structured file-selection record.
  */
 function buildStaticCheckFileRecord(
   inputPath: string,
   requestIndex: number,
   projectBasePath: string,
-  staticCheckConfig: Record<string, StaticCheckEntry[]>,
+  staticCheckConfig: Record<string, StaticCheckLanguageConfig>,
 ): StaticCheckFileRecord {
   void requestIndex;
   const absolutePath = path.resolve(projectBasePath, inputPath);
   const exists = fs.existsSync(absolutePath);
   const isFile = exists && fs.statSync(absolutePath).isFile();
   const languageName = isFile ? STATIC_CHECK_EXT_TO_LANG[path.extname(absolutePath).toLowerCase()] : undefined;
-  const configuredCheckers = languageName ? [...(staticCheckConfig[languageName] ?? [])] : [];
+  const configuredCheckers = languageName
+    ? getActiveStaticCheckEntries(staticCheckConfig, languageName)
+    : [];
   let status: StaticCheckFileRecord["status"] = "selected";
   let errorMessage: string | undefined;
   if (!exists) {
@@ -432,7 +246,7 @@ function buildStaticCheckFileRecord(
  * @param[in] requestedPaths {string[]} Explicit or discovered file paths.
  * @param[in] selectionDirectoryPaths {string[]} Directories that produced the selection.
  * @param[in] excludedDirectoryPaths {string[]} Directory roots excluded from project selection.
- * @param[in] staticCheckConfig {Record<string, StaticCheckEntry[]>} Effective static-check configuration.
+ * @param[in] staticCheckConfig {Record<string, StaticCheckLanguageConfig>} Effective static-check configuration.
  * @param[in] execution {ToolExecutionSection} Normalized execution metadata.
  * @return {StaticCheckToolPayload} Structured static-check payload.
  */
@@ -443,7 +257,7 @@ export function buildStaticCheckToolPayload(
   requestedPaths: string[],
   selectionDirectoryPaths: string[],
   excludedDirectoryPaths: string[],
-  staticCheckConfig: Record<string, StaticCheckEntry[]>,
+  staticCheckConfig: Record<string, StaticCheckLanguageConfig>,
   execution: ToolExecutionSection,
 ): StaticCheckToolPayload {
   void toolName;

package/src/core/compress-payload.ts

@@ -88,32 +88,20 @@ export interface CompressToolSymbolEntry extends CompressLineRange {
 
 /**
  * @brief Describes one per-file compression payload entry.
- * @details Stores path identity, compression metrics, rendered line-number mode, optional file-level and symbol-level metadata, structured compressed lines, and stable failure facts. The interface is compile-time only and introduces no runtime cost.
+ * @details Stores canonical identity, compression metrics, optional file-level and symbol-level metadata, structured compressed lines, and stable failure facts. Derivable identity fields and duplicate monolithic compressed text are intentionally omitted to reduce token cost. The interface is compile-time only and introduces no runtime cost.
  */
 export interface CompressToolFileEntry extends CompressLineRange {
-  request_index: number;
-  input_path: string;
   canonical_path: string;
-  absolute_path: string;
-  file_name: string;
-  file_extension: string;
-  language_id?: string;
-  language_name?: string;
   status: CompressFileStatus;
-  exists: boolean;
-  is_file: boolean;
-  line_number_mode: CompressLineNumberMode;
   source_line_count: number;
   compressed_line_count: number;
   removed_line_count: number;
   symbol_analysis_status: CompressSymbolAnalysisStatus;
   symbol_count: number;
   doxygen_field_count: number;
-  file_description_text?: string;
   file_doxygen?: StructuredDoxygenFields;
   symbols: CompressToolSymbolEntry[];
   compressed_lines: CompressToolLineEntry[];
-  compressed_source_text?: string;
   error_reason?: string;
   error_message?: string;
   symbol_analysis_error_message?: string;
@@ -154,12 +142,10 @@ export interface CompressToolSummarySection {
 
 /**
  * @brief Describes the repository section of the compression payload.
- * @details Stores the base path, configured source-directory scope, and canonical file list used during compression. The interface is compile-time only and introduces no runtime cost.
+ * @details Stores configured source-directory scope and the canonical file list used during compression. Static root-path echoes are intentionally omitted to reduce token cost. The interface is compile-time only and introduces no runtime cost.
  */
 export interface CompressToolRepositorySection {
-  root_directory_path: string;
   source_directory_paths: string[];
-  file_count: number;
   file_canonical_paths: string[];
 }
 
@@ -318,8 +304,8 @@ function analyzeCompressedFileSymbols(
       signature_text: element.signature,
       parent_symbol_name: parentSymbolName,
       parent_qualified_name: parentQualifiedName,
-      child_symbol_names: [],
-      child_qualified_names: [],
+      child_symbol_names: [] as string[],
+      child_qualified_names: [] as string[],
       depth: element.depth,
       brief_text: structuredDoxygen.brief?.[0],
       doxygen: Object.keys(structuredDoxygen).length > 0 ? structuredDoxygen : undefined,
@@ -380,9 +366,6 @@ function analyzeCompressFile(
   verbose: boolean,
 ): CompressToolFileEntry {
   const canonicalPath = canonicalizeCompressionPath(absolutePath, baseDir);
-  const fileName = path.basename(absolutePath);
-  const fileExtension = path.extname(absolutePath).toLowerCase();
-  const lineNumberMode: CompressLineNumberMode = includeLineNumbers ? "enabled" : "disabled";
   const languageId = detectLanguage(absolutePath);
 
   if (!languageId) {
@@ -391,16 +374,8 @@ function analyzeCompressFile(
     }
     return {
       ...buildLineRange(0, 0),
-      request_index: requestIndex,
-      input_path: inputPath,
       canonical_path: canonicalPath,
-      absolute_path: absolutePath,
-      file_name: fileName,
-      file_extension: fileExtension,
       status: "skipped",
-      exists: true,
-      is_file: true,
-      line_number_mode: lineNumberMode,
       source_line_count: 0,
       compressed_line_count: 0,
       removed_line_count: 0,
@@ -416,20 +391,16 @@ function analyzeCompressFile(
 
   try {
     const compression = compressFileDetailed(absolutePath, languageId, includeLineNumbers);
-    let languageName: string | undefined;
     let symbols: CompressToolSymbolEntry[] = [];
     let fileDoxygen: StructuredDoxygenFields | undefined;
-    let fileDescriptionText: string | undefined;
     let doxygenFieldCount = 0;
     let symbolAnalysisStatus: CompressSymbolAnalysisStatus = "not_attempted";
     let symbolAnalysisErrorMessage: string | undefined;
 
     try {
       const symbolAnalysis = analyzeCompressedFileSymbols(analyzer, absolutePath, canonicalPath, languageId);
-      languageName = symbolAnalysis.languageName;
       symbols = symbolAnalysis.symbols;
       fileDoxygen = symbolAnalysis.fileDoxygen;
-      fileDescriptionText = symbolAnalysis.fileDescriptionText;
       doxygenFieldCount = symbolAnalysis.doxygenFieldCount;
       symbolAnalysisStatus = "analyzed";
     } catch (error) {
@@ -446,29 +417,17 @@ function analyzeCompressFile(
 
     return {
       ...buildLineRange(compression.source_start_line_number, compression.source_end_line_number),
-      request_index: requestIndex,
-      input_path: inputPath,
       canonical_path: canonicalPath,
-      absolute_path: absolutePath,
-      file_name: fileName,
-      file_extension: fileExtension,
-      language_id: languageId,
-      language_name: languageName,
       status: "compressed",
-      exists: true,
-      is_file: true,
-      line_number_mode: lineNumberMode,
       source_line_count: compression.source_line_count,
       compressed_line_count: compression.compressed_line_count,
       removed_line_count: compression.removed_line_count,
       symbol_analysis_status: symbolAnalysisStatus,
       symbol_count: symbols.length,
       doxygen_field_count: doxygenFieldCount,
-      file_description_text: fileDescriptionText,
       file_doxygen: fileDoxygen,
       symbols,
       compressed_lines: mapCompressedLines(compression.compressed_lines),
-      compressed_source_text: compression.compressed_source_text,
       symbol_analysis_error_message: symbolAnalysisErrorMessage,
     };
   } catch (error) {
@@ -478,17 +437,8 @@ function analyzeCompressFile(
     }
     return {
       ...buildLineRange(0, 0),
-      request_index: requestIndex,
-      input_path: inputPath,
       canonical_path: canonicalPath,
-      absolute_path: absolutePath,
-      file_name: fileName,
-      file_extension: fileExtension,
-      language_id: languageId,
       status: "error",
-      exists: true,
-      is_file: true,
-      line_number_mode: lineNumberMode,
       source_line_count: 0,
       compressed_line_count: 0,
       removed_line_count: 0,
@@ -527,24 +477,14 @@ export function buildCompressToolPayload(options: BuildCompressToolPayloadOption
   const files: CompressToolFileEntry[] = requestedPaths.map((requestedPath, requestIndex) => {
     const absolutePath = path.resolve(absoluteBaseDir, requestedPath);
     const canonicalPath = canonicalizeCompressionPath(absolutePath, absoluteBaseDir);
-    const fileName = path.basename(absolutePath);
-    const fileExtension = path.extname(absolutePath).toLowerCase();
     if (!fs.existsSync(absolutePath)) {
       if (verbose) {
         console.error(`  SKIP  ${requestedPath} (file not found)`);
       }
       return {
         ...buildLineRange(0, 0),
-        request_index: requestIndex,
-        input_path: requestedPath,
         canonical_path: canonicalPath,
-        absolute_path: absolutePath,
-        file_name: fileName,
-        file_extension: fileExtension,
         status: "skipped",
-        exists: false,
-        is_file: false,
-        line_number_mode: lineNumberMode,
         source_line_count: 0,
         compressed_line_count: 0,
         removed_line_count: 0,
@@ -564,16 +504,8 @@ export function buildCompressToolPayload(options: BuildCompressToolPayloadOption
       }
       return {
         ...buildLineRange(0, 0),
-        request_index: requestIndex,
-        input_path: requestedPath,
         canonical_path: canonicalPath,
-        absolute_path: absolutePath,
-        file_name: fileName,
-        file_extension: fileExtension,
         status: "skipped",
-        exists: true,
-        is_file: false,
-        line_number_mode: lineNumberMode,
         source_line_count: 0,
         compressed_line_count: 0,
         removed_line_count: 0,
@@ -610,9 +542,7 @@ export function buildCompressToolPayload(options: BuildCompressToolPayloadOption
       total_doxygen_field_count: compressedFiles.reduce((sum, file) => sum + file.doxygen_field_count, 0),
     },
     repository: {
-      root_directory_path: absoluteBaseDir,
       source_directory_paths: [...sourceDirectoryPaths],
-      file_count: files.length,
       file_canonical_paths: files.map((file) => file.canonical_path),
     },
     files,

package/src/core/compress.ts

@@ -240,9 +240,30 @@ function formatCompressedSourceText(entries: CompressedLineEntry[]): string {
   return entries.map((entry) => entry.display_text).join("\n");
 }
 
+/**
+ * @brief Normalizes one retained source line while preserving requested indentation semantics.
+ * @details Preserves the full leading whitespace prefix for indentation-significant languages and for any other line whose leading indentation contains at least one tab, while trimming leading whitespace for space-only indentation in other languages. Runtime is O(n) in line length. No external state is mutated.
+ * @param[in] line {string} Candidate source line after comment removal.
+ * @param[in] preserveIndent {boolean} Whether the language requires full indentation preservation.
+ * @return {string} Normalized retained line, or an empty string when no content remains.
+ */
+function normalizeRetainedLineIndentation(line: string, preserveIndent: boolean): string {
+  const content = line.trim();
+  if (!content) {
+    return "";
+  }
+
+  const leading = line.slice(0, line.length - line.trimStart().length);
+  if (preserveIndent || leading.includes("\t")) {
+    return `${leading}${content}`;
+  }
+
+  return content;
+}
+
 /**
  * @brief Compresses in-memory source text into the structured compression model.
- * @details Removes blank lines and comments, preserves shebangs, respects string-literal boundaries, retains leading indentation for indentation-significant languages, and emits both structured line entries and a rendered text excerpt. Runtime is O(n) in source length. No external state is mutated.
+ * @details Removes blank lines and comments, preserves shebangs, respects string-literal boundaries, retains full leading indentation for indentation-significant languages, preserves leading-tab indentation for other languages, and emits both structured line entries and a rendered text excerpt. Runtime is O(n) in source length. No external state is mutated.
  * @param[in] source {string} Raw source text.
  * @param[in] language {string} Canonical compression language identifier.
  * @param[in] includeLineNumbers {boolean} When `true`, prefix rendered text lines with original source line numbers.
@@ -375,20 +396,10 @@ export function compressSourceDetailed(source: string, language: string, include
       line = removeInlineComment(line, spec.singleComment, stringDelimiters);
     }
 
-    if (preserveIndent) {
-      const leading = line.slice(0, line.length - line.trimStart().length);
-      const content = line.trim();
-      if (!content) {
-        index += 1;
-        continue;
-      }
-      line = `${leading}${content}`;
-    } else {
-      line = line.trim();
-      if (!line) {
-        index += 1;
-        continue;
-      }
+    line = normalizeRetainedLineIndentation(line, preserveIndent);
+    if (!line) {
+      index += 1;
+      continue;
     }
 
     line = line.replace(/[ \t]+$/g, "");