feat: truncate logs and inject memory into prompts to reduce token burn

This change implements several optimizations to reduce token consumption and improve agent context:

1.  **Log Truncation**: `scripts/agent/run-scheduler-cycle.mjs` now truncates the echoed output of spawned processes to 20KB per stream (stdout/stderr). This prevents the scheduler agent's context from being flooded with excessive logs from sub-agents.
2.  **Memory Injection**: `torch-config.json`'s `retrieveCommand` has been updated to write retrieved memories to `.scheduler-memory/latest/<cadence>/memories.md`. `scripts/agent/run-selected-prompt.mjs` now checks for this file and injects its content into the agent's prompt, providing immediate context from the memory system.
3.  **CLI Optimization**: The `torch-lock list-memories` command now truncates the `content` field of memories to 200 characters by default. A new `--full` flag has been added to `src/cli-parser.mjs` and `src/lib.mjs` to view the full content when needed.

These changes aim to make the agent process more efficient ("error on the side of caution") and leverage the memory system more effectively.

Co-authored-by: PR0M3TH3AN <[email protected]>

scripts/agent/run-scheduler-cycle.mjs

@@ -86,16 +86,48 @@ async function runCommand(command, args = [], options = {}) {
     let stdout = '';
     let stderr = '';
 
+    const OUTPUT_LIMIT = 20000; // 20KB
+    let stdoutWritten = 0;
+    let stderrWritten = 0;
+    let stdoutTruncated = false;
+    let stderrTruncated = false;
+
     child.stdout.on('data', (chunk) => {
       const text = chunk.toString();
       stdout += text;
-      process.stdout.write(text);
+
+      if (stdoutWritten < OUTPUT_LIMIT) {
+        const remaining = OUTPUT_LIMIT - stdoutWritten;
+        if (text.length <= remaining) {
+          process.stdout.write(text);
+          stdoutWritten += text.length;
+        } else {
+          process.stdout.write(text.slice(0, remaining));
+          stdoutWritten += remaining;
+        }
+      } else if (!stdoutTruncated) {
+        process.stdout.write('\n...[stdout truncated]...\n');
+        stdoutTruncated = true;
+      }
     });
 
     child.stderr.on('data', (chunk) => {
       const text = chunk.toString();
       stderr += text;
-      process.stderr.write(text);
+
+      if (stderrWritten < OUTPUT_LIMIT) {
+        const remaining = OUTPUT_LIMIT - stderrWritten;
+        if (text.length <= remaining) {
+          process.stderr.write(text);
+          stderrWritten += text.length;
+        } else {
+          process.stderr.write(text.slice(0, remaining));
+          stderrWritten += remaining;
+        }
+      } else if (!stderrTruncated) {
+        process.stderr.write('\n...[stderr truncated]...\n');
+        stderrTruncated = true;
+      }
     });
 
     child.on('close', (code) => {

scripts/agent/run-selected-prompt.mjs

@@ -52,6 +52,20 @@ async function main() {
     fail(`Scheduler prompt at ${promptPath} is empty.`);
   }
 
+  const cadence = process.env.SCHEDULER_CADENCE;
+  const memoriesPath = path.resolve(process.cwd(), `.scheduler-memory/latest/${cadence}/memories.md`);
+  try {
+    const memories = await fs.readFile(memoriesPath, 'utf8');
+    if (memories && memories.trim()) {
+      promptMarkdown += `\n\n# Retrieved Memories\n\n${memories.trim()}\n`;
+      console.error(`[scheduler] Injected memories from ${memoriesPath}`);
+    }
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      console.error(`[scheduler] Warning: Failed to read memories from ${memoriesPath}: ${error.message}`);
+    }
+  }
+
   const runner = resolveRunner(promptMarkdown);
   const child = spawn(runner.command, runner.args, {
     cwd: process.cwd(),