added new instruct pipeline for faster generation

USAGE.md

@@ -67,6 +67,16 @@ If you need to cap questions per chunk:
 QUESTION_MAX_PER_CHUNK=3
 ```
 
+### Random-walk over chunks
+
+Shuffle the chunk order (crypto-random) to reduce ordering bias:
+
+```bash
+PIPELINE_RANDOM_WALK=1 QUESTION_MAX_PER_CHUNK=3 npm run pipeline -- --limit 3 --chunk-limit 10 --verbose
+```
+
+Equivalent toggle: `PIPELINE_CHUNK_ORDER=random`. `--chunk-limit` (or `PIPELINE_CHUNK_LIMIT`) caps how many chunks are sampled.
+
 ---
 
 # 3. **Understanding Output**
@@ -108,6 +118,11 @@ GENERATOR_MODEL=qwen3-vl:8b-thinking
 VERIFIER_MODEL=tensortemplar/patronus-lynx:8b-instruct-q4_K_M
 REWARD_MODEL=tensortemplar/patronus-lynx:8b-instruct-q4_K_M
 QUESTION_MODEL=qwen2.5-7b-instruct
+
+# instruct-only generator (optional)
+INSTRUCT_PIPELINE=0
+INSTRUCT_GENERATOR_MODEL=phi-4-instruct
+INSTRUCT_GENERATOR_PROVIDER=ollama
 ```
 
 Retrieval configuration:
@@ -124,6 +139,15 @@ EMBED_URL=http://localhost:11434/api/embeddings
 EMBED_MODEL=mxbai-embed-large
 ```
 
+General pipeline knobs:
+```
+PIPELINE_SEED_MODE=question-first   # or static
+PIPELINE_RANDOM_WALK=0              # set 1 for shuffled chunks
+QUESTION_MAX_PER_CHUNK=5
+# PIPELINE_CHUNK_LIMIT=10           # optional chunk cap
+# PIPELINE_CACHE_DIR=data/cache     # override cache dir (e.g., data/cache_instruct)
+```
+
 ---
 
 # 5. **Debugging Tips**
@@ -155,6 +179,20 @@ node ./src/question/question_cli.mjs "Give me questions about freedom"
 node ./src/generator/generator_cli.mjs "What is love?"
 ```
 
+### Try generator prompt with cached chunk/question:
+
+```bash
+# picks first cached chunk + question
+scripts/try_generator_prompt.sh
+
+# pick specific cached chunk/question
+scripts/try_generator_prompt.sh <chunk_id> <question_index>
+
+# random cached chunk/question + reasoning mode
+scripts/try_generator_prompt.sh --random -r
+```
+Uses `data/cache/questions.jsonl` + `data/rag_chunks.jsonl` and injects them into `prompts/generator_prompt.txt`. It picks the first matching cached chunk ID in the rag file (or random with `--random`). Override via `PIPELINE_CACHE_DIR`, `RAG_CHUNKS_PATH`, `PROMPT_FILE`, `GENERATOR_MODEL`, `OLLAMA_URL`. If no cached chunk IDs match the rag chunks, run the pipeline once to populate the cache.
+
 ---
 
 # 6. **Full End-to-End (Question-First) Verbose Run**
@@ -174,6 +212,57 @@ You should see:
 * verifier judgement
 * reward score
 
+### Long overnight runs
+
+To let the pipeline keep going until you stop it, drop `--limit` (process all available seeds/chunks) or set a very high limit. For a basic “run all cached chunks with random walk” overnight job:
+
+```bash
+PIPELINE_SEED_MODE=question-first \
+PIPELINE_RANDOM_WALK=1 \
+QUESTION_MAX_PER_CHUNK=5 \
+npm run pipeline -- --verbose
+```
+
+If you prefer a hard cap instead of truly unbounded, set `--limit <N>` or `PIPELINE_CHUNK_LIMIT`. To run it in a loop until you Ctrl+C:
+
+```bash
+while true; do
+  PIPELINE_SEED_MODE=question-first PIPELINE_RANDOM_WALK=1 npm run pipeline -- --verbose
+  sleep 10
+done
+```
+
+# 7. **Instruct-only generator runs**
+
+Use an instruct model without touching the default “thinking” pipeline:
+
+```bash
+INSTRUCT_PIPELINE=1 \
+INSTRUCT_GENERATOR_MODEL=<your-instruct-model> \
+PIPELINE_CACHE_DIR=data/cache_instruct \
+npm run pipeline -- --out gold/pipeline_gold_instruct.jsonl --verbose
+```
+
+What it does:
+- switches the generator model/provider to `INSTRUCT_GENERATOR_MODEL` (and `INSTRUCT_GENERATOR_PROVIDER` if set),
+- keeps verifier/reward unchanged (configure `VERIFIER_MODEL`/`REWARD_MODEL` if you want lighter models),
+- defaults the output to `gold/pipeline_gold_instruct.jsonl` unless you pass `--out`.
+
+Keep caches separate by setting `PIPELINE_CACHE_DIR` for instruct runs (e.g., `data/cache_instruct`) so you don’t mix artifacts with the thinking pipeline. The default cache path is unchanged unless you override it.
+
+### One-liner scripts for continuous runs
+
+Thinking pipeline (random-walk, no limit, restarts every 10s):
+```
+scripts/run_thinking_continuous.sh
+```
+
+Instruct pipeline (needs `INSTRUCT_GENERATOR_MODEL`, uses separate cache/output):
+```
+INSTRUCT_GENERATOR_MODEL=<your-model> scripts/run_instruct_continuous.sh
+```
+Configure `INSTRUCT_GENERATOR_PROVIDER`, `PIPELINE_CACHE_DIR`, or `INSTRUCT_OUT` as needed; stop with Ctrl+C.
+
 ---
 
 # 7. **Output Cleanup**

scripts/cache_report.mjs

@@ -10,14 +10,39 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const PROJECT_ROOT = path.join(__dirname, '..');
 
-const CACHE_DIR = (() => {
-  const custom = process.env.PIPELINE_CACHE_DIR;
-  if (custom) {
-    return path.isAbsolute(custom)
-      ? custom
-      : path.join(PROJECT_ROOT, custom);
+const DEFAULT_CACHE_DIR = path.join(PROJECT_ROOT, 'data', 'cache');
+const INSTRUCT_CACHE_DIR = path.join(PROJECT_ROOT, 'data', 'cache_instruct');
+
+const MODE = (() => {
+  const v = process.env.CACHE_REPORT_MODE;
+  if (!v) return 'both';
+  const s = String(v).toLowerCase();
+  if (['thinking', 'default'].includes(s)) return 'thinking';
+  if (['instruct'].includes(s)) return 'instruct';
+  if (['both', 'all'].includes(s)) return 'both';
+  return 'both';
+})();
+
+const customDir = process.env.PIPELINE_CACHE_DIR
+  ? (path.isAbsolute(process.env.PIPELINE_CACHE_DIR)
+      ? process.env.PIPELINE_CACHE_DIR
+      : path.join(PROJECT_ROOT, process.env.PIPELINE_CACHE_DIR))
+  : null;
+
+const CACHE_DIRS = (() => {
+  if (customDir) {
+    return [{ label: 'custom', dir: customDir }];
   }
-  return path.join(PROJECT_ROOT, 'data', 'cache');
+  if (MODE === 'thinking') {
+    return [{ label: 'thinking (default)', dir: DEFAULT_CACHE_DIR }];
+  }
+  if (MODE === 'instruct') {
+    return [{ label: 'instruct', dir: INSTRUCT_CACHE_DIR }];
+  }
+  return [
+    { label: 'thinking (default)', dir: DEFAULT_CACHE_DIR },
+    { label: 'instruct', dir: INSTRUCT_CACHE_DIR },
+  ];
 })();
 
 const FILES = {
@@ -27,8 +52,8 @@ const FILES = {
   rewards: 'rewards.jsonl',
 };
 
-async function readJsonl(fileName) {
-  const filePath = path.join(CACHE_DIR, fileName);
+async function readJsonl(cacheDir, fileName) {
+  const filePath = path.join(cacheDir, fileName);
   try {
     const txt = await fs.readFile(filePath, 'utf8');
     return txt
@@ -54,47 +79,56 @@ function uniq(arr) {
 }
 
 async function main() {
-  const questions = await readJsonl(FILES.questions);
-  const generations = await readJsonl(FILES.generations);
-  const verifications = await readJsonl(FILES.verifications);
-  const rewards = await readJsonl(FILES.rewards);
-
-  const chunkIds = uniq([
-    ...questions.map((r) => r.chunk_id),
-    ...generations.map((r) => r.chunk_id),
-    ...verifications.map((r) => r.chunk_id),
-    ...rewards.map((r) => r.chunk_id),
-  ].filter(Boolean));
-
-  const totalQuestions = questions.reduce((acc, r) => {
-    if (Array.isArray(r.questions)) return acc + r.questions.length;
-    if (Array.isArray(r.question_ids)) return acc + r.question_ids.length;
-    return acc + 1;
-  }, 0);
-
-  const totalGenerations = generations.length;
-  const totalVerifications = verifications.length;
-  const totalRewards = rewards.length;
-
-  const passedVerifications = verifications.filter((v) => v.ok === true).length;
-  const passedRewards = rewards.filter((r) => r.ok === true).length;
-
-  const rows = [
-    ['Cache dir', CACHE_DIR],
-    ['Unique chunks', chunkIds.length],
-    ['Question records', questions.length],
-    ['Questions total', totalQuestions],
-    ['Generation records', totalGenerations],
-    ['Verification records', totalVerifications],
-    ['Verifications ok', passedVerifications],
-    ['Reward records', totalRewards],
-    ['Rewards ok', passedRewards],
-  ];
+  if (customDir) {
+    console.log(`CACHE_REPORT_MODE=custom (PIPELINE_CACHE_DIR=${customDir})`);
+  } else {
+    console.log(`CACHE_REPORT_MODE=${MODE}`);
+  }
+
+  for (const { label, dir } of CACHE_DIRS) {
+    const questions = await readJsonl(dir, FILES.questions);
+    const generations = await readJsonl(dir, FILES.generations);
+    const verifications = await readJsonl(dir, FILES.verifications);
+    const rewards = await readJsonl(dir, FILES.rewards);
+
+    const chunkIds = uniq([
+      ...questions.map((r) => r.chunk_id),
+      ...generations.map((r) => r.chunk_id),
+      ...verifications.map((r) => r.chunk_id),
+      ...rewards.map((r) => r.chunk_id),
+    ].filter(Boolean));
+
+    const totalQuestions = questions.reduce((acc, r) => {
+      if (Array.isArray(r.questions)) return acc + r.questions.length;
+      if (Array.isArray(r.question_ids)) return acc + r.question_ids.length;
+      return acc + 1;
+    }, 0);
+
+    const totalGenerations = generations.length;
+    const totalVerifications = verifications.length;
+    const totalRewards = rewards.length;
+
+    const passedVerifications = verifications.filter((v) => v.ok === true).length;
+    const passedRewards = rewards.filter((r) => r.ok === true).length;
+
+    console.log(`\n== ${label} cache ==`);
+    const rows = [
+      ['Cache dir', dir],
+      ['Unique chunks', chunkIds.length],
+      ['Question records', questions.length],
+      ['Questions total', totalQuestions],
+      ['Generation records', totalGenerations],
+      ['Verification records', totalVerifications],
+      ['Verifications ok', passedVerifications],
+      ['Reward records', totalRewards],
+      ['Rewards ok', passedRewards],
+    ];
 
-  const colWidth = Math.max(...rows.map(([k]) => k.length)) + 2;
-  for (const [key, val] of rows) {
-    const pad = ' '.repeat(colWidth - key.length);
-    console.log(`${key}:${pad}${val}`);
+    const colWidth = Math.max(...rows.map(([k]) => k.length)) + 2;
+    for (const [key, val] of rows) {
+      const pad = ' '.repeat(colWidth - key.length);
+      console.log(`${key}:${pad}${val}`);
+    }
   }
 }
 

scripts/run_instruct_continuous.sh

@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Continuous instruct-only pipeline runner.
+# - Uses separate cache/output to avoid mixing with thinking pipeline
+# - Random-walk over chunks
+# - No limit: processes all available chunks/questions; loop restarts after completion
+#
+# Required: set INSTRUCT_GENERATOR_MODEL (and optionally INSTRUCT_GENERATOR_PROVIDER).
+# Stop with Ctrl+C.
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+# Load .env if present
+if [[ -f "$ROOT_DIR/.env" ]]; then
+  set -a
+  source "$ROOT_DIR/.env"
+  set +a
+fi
+
+if [[ -z "${INSTRUCT_GENERATOR_MODEL:-}" ]]; then
+  echo "❌ Please set INSTRUCT_GENERATOR_MODEL to your instruct model." >&2
+  exit 1
+fi
+
+while true; do
+  INSTRUCT_PIPELINE=1 \
+  INSTRUCT_GENERATOR_MODEL="$INSTRUCT_GENERATOR_MODEL" \
+  INSTRUCT_GENERATOR_PROVIDER="${INSTRUCT_GENERATOR_PROVIDER:-${GENERATOR_PROVIDER:-ollama}}" \
+  PIPELINE_CACHE_DIR="${PIPELINE_CACHE_DIR:-$ROOT_DIR/data/cache_instruct}" \
+  PIPELINE_SEED_MODE=question-first \
+  PIPELINE_RANDOM_WALK=1 \
+  QUESTION_MAX_PER_CHUNK="${QUESTION_MAX_PER_CHUNK:-5}" \
+  npm run pipeline -- \
+    --out "${INSTRUCT_OUT:-$ROOT_DIR/gold/pipeline_gold_instruct.jsonl}" \
+    --verbose
+
+  echo "Instruct run finished at $(date). Sleeping 10s before next loop..."
+  sleep 10
+done

scripts/run_thinking_continuous.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Continuous "thinking" pipeline runner.
+# - Uses default thinking cache/output
+# - Random-walk over chunks
+# - No limit: processes all available chunks/questions; loop restarts after completion
+#
+# Stop with Ctrl+C.
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+# Load .env if present
+if [[ -f "$ROOT_DIR/.env" ]]; then
+  set -a
+  source "$ROOT_DIR/.env"
+  set +a
+fi
+
+while true; do
+  PIPELINE_SEED_MODE=question-first \
+  PIPELINE_RANDOM_WALK=1 \
+  QUESTION_MAX_PER_CHUNK="${QUESTION_MAX_PER_CHUNK:-5}" \
+  npm run pipeline -- --verbose
+
+  echo "Run finished at $(date). Sleeping 10s before next loop..."
+  sleep 10
+done

scripts/try_generator_prompt.sh

@@ -0,0 +1,227 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Usage:
+#   scripts/try_generator_prompt.sh [chunk_id] [question_index] [-r] [--random]
+#   - chunk_id: optional. default = first cached chunk in questions cache
+#   - question_index: 0-based index into the cached question list for that chunk (default 0)
+#   - -r / --reasoning: enable Ollama reasoning option
+#   - --random: pick a random cached chunk and random question (ignores positional args)
+#
+# Requirements: jq, node, cache populated (data/cache/questions.jsonl) and rag chunks file (data/rag_chunks.jsonl)
+
+CHUNK_ID=""
+QUESTION_INDEX=0
+REASONING=0
+RANDOM_MODE=0
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -r|--reasoning)
+      REASONING=1
+      shift
+      ;;
+    --random)
+      RANDOM_MODE=1
+      shift
+      ;;
+    *)
+      if [[ -z "$CHUNK_ID" ]]; then
+        CHUNK_ID="$1"
+      else
+        QUESTION_INDEX="$1"
+      fi
+      shift
+      ;;
+  esac
+done
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+CACHE_DIR="${PIPELINE_CACHE_DIR:-$ROOT_DIR/data/cache}"
+QUESTIONS_FILE="${CACHE_DIR}/questions.jsonl"
+RAG_PATH="${RAG_CHUNKS_PATH:-$ROOT_DIR/data/rag_chunks.jsonl}"
+PROMPT_FILE="${PROMPT_FILE:-$ROOT_DIR/prompts/generator_prompt.txt}"
+MODEL="${GENERATOR_MODEL:-${OLLAMA_MODEL:-qwen3-vl:8b-thinking}}"
+OLLAMA_URL="${OLLAMA_URL:-http://localhost:11434}"
+
+if [[ ! -f "$QUESTIONS_FILE" ]]; then
+  echo "❌ questions cache not found at $QUESTIONS_FILE" >&2
+  exit 1
+fi
+
+if [[ ! -f "$RAG_PATH" ]]; then
+  echo "❌ rag chunks file not found at $RAG_PATH" >&2
+  exit 1
+fi
+
+if [[ ! -f "$PROMPT_FILE" ]]; then
+  echo "❌ generator prompt not found at $PROMPT_FILE" >&2
+  exit 1
+fi
+
+NODE_OUTPUT="$(CHUNK_ID="$CHUNK_ID" QUESTION_INDEX="$QUESTION_INDEX" QUESTIONS_FILE="$QUESTIONS_FILE" RAG_PATH="$RAG_PATH" RANDOM_MODE="$RANDOM_MODE" node --input-type=module <<'NODE'
+import fs from 'fs';
+import crypto from 'crypto';
+
+const chunkIdArg = process.env.CHUNK_ID || '';
+const qIndex = Number(process.env.QUESTION_INDEX || '0');
+const questionsFile = process.env.QUESTIONS_FILE;
+const ragPath = process.env.RAG_PATH;
+const randomMode = process.env.RANDOM_MODE === '1';
+
+function normalizeText(text = '') {
+  return String(text).replace(/\s+/g, ' ').trim();
+}
+
+function chunkIdFromContent(content, sourceId) {
+  const base = normalizeText(content);
+  return crypto.createHash('sha256').update(`${base}|${sourceId ?? ''}`).digest('hex');
+}
+
+function fail(msg) {
+  console.error(msg);
+  process.exit(2);
+}
+
+const questionLines = fs.readFileSync(questionsFile, 'utf8')
+  .split('\n')
+  .map((l) => l.trim())
+  .filter(Boolean);
+const records = questionLines.map((l) => {
+  try {
+    return JSON.parse(l);
+  } catch {
+    return null;
+  }
+}).filter(Boolean);
+
+if (records.length === 0) fail('No cached questions found.');
+
+const ragLines = fs.readFileSync(ragPath, 'utf8')
+  .split('\n')
+  .map((l) => l.trim())
+  .filter(Boolean);
+
+const ragMap = new Map();
+ragLines.forEach((line, idx) => {
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return;
+  }
+  const content =
+    obj.content ||
+    obj.text ||
+    obj.chunk ||
+    obj.body ||
+    '';
+  const sourceId =
+    obj.id ||
+    obj.session_key ||
+    obj.title ||
+    `jsonl-${idx}`;
+  const cid = chunkIdFromContent(content, sourceId);
+  ragMap.set(cid, { content, sourceId, source: obj });
+});
+
+const matchingRecords = records.filter((r) => ragMap.has(r.chunk_id));
+
+let record = null;
+if (chunkIdArg) {
+  record = records.find((r) => r.chunk_id === chunkIdArg);
+  if (!record) fail(`Chunk ${chunkIdArg} not found in questions cache.`);
+  if (!ragMap.has(record.chunk_id)) {
+    fail(`Chunk content for ${record.chunk_id} not found in ${ragPath}.`);
+  }
+} else if (randomMode) {
+  if (matchingRecords.length === 0) {
+    fail('No cached chunk IDs match rag chunks. Run the pipeline to populate cache.');
+  }
+  record = matchingRecords[crypto.randomInt(matchingRecords.length)];
+} else {
+  record = matchingRecords[0];
+  if (!record) {
+    fail('No cached chunk IDs match rag chunks. Run the pipeline to populate cache.');
+  }
+}
+
+const questions = record.questions || [];
+let chosenQIndex = qIndex;
+if (randomMode) {
+  chosenQIndex = questions.length > 0 ? crypto.randomInt(questions.length) : 0;
+}
+const question = questions?.[chosenQIndex];
+if (!question) fail(`Question index ${qIndex} out of range for chunk ${record.chunk_id}.`);
+
+const matchedChunk = ragMap.get(record.chunk_id);
+
+console.log(JSON.stringify({
+  chunkId: record.chunk_id,
+  question,
+  questionIndex: chosenQIndex,
+  chunk: matchedChunk.content,
+  source: matchedChunk.source,
+}));
+NODE
+)"
+
+CHUNK_ID_RESOLVED="$(echo "$NODE_OUTPUT" | jq -r '.chunkId')"
+QUESTION="$(echo "$NODE_OUTPUT" | jq -r '.question')"
+CHUNK="$(echo "$NODE_OUTPUT" | jq -r '.chunk')"
+QUESTION_INDEX="$(echo "$NODE_OUTPUT" | jq -r '.questionIndex')"
+
+echo "🧩 Chunk: $CHUNK_ID_RESOLVED"
+echo "   Question [$QUESTION_INDEX]: $QUESTION"
+echo "   Model: $MODEL"
+echo "   Prompt file: $PROMPT_FILE"
+echo "----------------------------------------------"
+echo "$CHUNK" | head -n 20
+echo "… (chunk truncated)"
+echo "----------------------------------------------"
+
+PROMPT="$(QUESTION="$QUESTION" CHUNK="$CHUNK" PROMPT_FILE="$PROMPT_FILE" node --input-type=module <<'NODE'
+import fs from 'fs';
+const tpl = fs.readFileSync(process.env.PROMPT_FILE, 'utf8');
+const question = process.env.QUESTION;
+const context = process.env.CHUNK;
+const out = tpl
+  .split('{{QUESTION}}').join(question)
+  .split('{{CONTEXT}}').join(context);
+process.stdout.write(out);
+NODE
+)"
+
+PROMPT_JSON=$(printf '%s' "$PROMPT" | jq -Rs .)
+
+if [[ "$REASONING" == "1" ]]; then
+  echo "🧠 Reasoning: ON"
+  OPTIONS='"options":{"reasoning":true},'
+else
+  OPTIONS=""
+fi
+
+PAYLOAD=$(cat <<EOF
+{
+  "model": "$MODEL",
+  "prompt": $PROMPT_JSON,
+  $OPTIONS
+  "stream": false
+}
+EOF
+)
+
+echo
+echo "🚀 Sending to Ollama ($MODEL)…"
+echo
+
+RAW_RESPONSE=$(mktemp)
+curl -s -X POST "$OLLAMA_URL/api/generate" \
+  -H "Content-Type: application/json" \
+  -d "$PAYLOAD" | tee "$RAW_RESPONSE" \
+  | jq 'del(.context)'
+
+
+echo
+echo "📝 Response text:"
+jq -r '.response // .message // .output' "$RAW_RESPONSE"

src/generator/generator_core.mjs

@@ -22,11 +22,16 @@ export async function runGenerator(question, contextChunks, provider) {
     .replace('{{QUESTION}}', question)
     .replace('{{CONTEXT}}', ctxText);
 
-  const response = await provider.generate(prompt);
+  const response = await provider.generate(prompt, { includeJson: true });
 
   // Normalize provider output: string or { response, thinking }
   const raw = typeof response === 'string' ? response : response?.response ?? '';
   const thinkingObj = typeof response === 'object' && response?.thinking ? response.thinking : null;
+  const rawJson =
+  typeof response === 'object' && response?.fullResponse
+    ? (({ context, ...rest }) => rest)(response.fullResponse)
+    : null;
+
 
   let thought = null;
   let answer = raw?.trim?.() ?? raw;
@@ -192,7 +197,8 @@ export async function runGenerator(question, contextChunks, provider) {
     evidence,
     limitations,
     question,
-    context: contextChunks
+    context: contextChunks,
+    rawJson,
   };
 }
 

src/pipeline/pipeline_cli.js

@@ -18,12 +18,18 @@ const DEFAULT_OUT = path.join(
   'gold',
   'pipeline_gold.jsonl',
 );
+const DEFAULT_INSTRUCT_OUT = path.join(
+  PROJECT_ROOT,
+  'gold',
+  'pipeline_gold_instruct.jsonl',
+);
 
 function parseArgs(argv) {
   const args = argv.slice(2);
   let limit;
   let seedsPath;
   let outPath;
+  let outPathProvided = false;
   let verbose = true; // default verbose on
   let seedMode; // optional CLI override
   let chunkLimit;
@@ -39,6 +45,7 @@ function parseArgs(argv) {
       i++;
     } else if (a === '--out') {
       outPath = args[i + 1];
+      outPathProvided = true;
       i++;
     } else if (a === '--chunk-limit') {
       const v = Number(args[i + 1]);
@@ -64,6 +71,7 @@ function parseArgs(argv) {
     limit,
     seedsPath: seedsPath || DEFAULT_SEEDS,
     outPath: outPath || DEFAULT_OUT,
+    outPathProvided,
     verbose,
     seedMode,
     chunkLimit,
@@ -75,24 +83,54 @@ async function main() {
     limit,
     seedsPath,
     outPath,
+    outPathProvided,
     verbose,
     seedMode: cliSeedMode,
     chunkLimit,
   } = parseArgs(process.argv);
 
-  const generatorProvider = process.env.GENERATOR_PROVIDER || 'ollama';
-  const verifierProvider = process.env.VERIFIER_PROVIDER || generatorProvider;
-  const rewardProvider = process.env.REWARD_PROVIDER || generatorProvider;
+  const instructMode = (() => {
+    const v = process.env.INSTRUCT_PIPELINE;
+    if (!v) return false;
+    const s = String(v).toLowerCase();
+    return s === '1' || s === 'true' || s === 'yes';
+  })();
+
+  let effectiveOutPath = outPath;
+  if (instructMode && !outPathProvided && outPath === DEFAULT_OUT) {
+    effectiveOutPath = DEFAULT_INSTRUCT_OUT;
+  }
+
+  const baseGeneratorProvider = process.env.GENERATOR_PROVIDER || 'ollama';
+  const verifierProvider = process.env.VERIFIER_PROVIDER || baseGeneratorProvider;
+  const rewardProvider = process.env.REWARD_PROVIDER || baseGeneratorProvider;
+
+  const instructProvider =
+    process.env.INSTRUCT_GENERATOR_PROVIDER || baseGeneratorProvider;
+
+  const generatorModel = (() => {
+    const instructModel =
+      process.env.INSTRUCT_GENERATOR_MODEL ||
+      process.env.INSTRUCT_GENERATOR;
+    if (instructMode && instructModel) return instructModel;
+    return (
+      process.env.GENERATOR_MODEL ||
+      process.env.OLLAMA_MODEL ||
+      'qwen3-vl:8b-thinking'
+    );
+  })();
 
-  const generatorModel =
-    process.env.GENERATOR_MODEL ||
-    process.env.OLLAMA_MODEL ||
-    'qwen3-vl:8b-thinking';
   const verifierModel =
     process.env.VERIFIER_MODEL || generatorModel;
   const rewardModel =
     process.env.REWARD_MODEL || verifierModel;
 
+  if (instructMode) {
+    // steer pipeline stages to the instruct generator
+    process.env.GENERATOR_PROVIDER = instructProvider;
+    process.env.GENERATOR_MODEL = generatorModel;
+  }
+
   // Resolve mode: CLI > env > default
   const mode =
     cliSeedMode || process.env.PIPELINE_SEED_MODE || 'question-first';
@@ -101,10 +139,10 @@ async function main() {
   console.log('🚀 Starting Distillation Pipeline');
   console.log(`   Mode:     ${mode}`);
   console.log(`   Seeds:    ${seedsPath}`);
-  console.log(`   Output:   ${outPath}`);
+  console.log(`   Output:   ${effectiveOutPath}`);
   console.log(`   Providers:`);
   console.log(
-    `     generator: ${generatorProvider} (${generatorModel})`,
+    `     generator: ${instructMode ? instructProvider : baseGeneratorProvider} (${generatorModel})`,
   );
   console.log(
     `     verifier:  ${verifierProvider} (${verifierModel})`,
@@ -127,7 +165,7 @@ async function main() {
   try {
     const result = await runPipelineBatch({
       seedsPath,
-      outPath,
+      outPath: effectiveOutPath,
       limit,
       chunkLimit,
       verbose,

src/pipeline/step.mjs

@@ -203,6 +203,15 @@ export async function runPipelineStep({
           log('   [generator] raw response (JSON if parsable):');
           log('   ' + preview(rawDisplay, 2000).replace(/\n/g, '\n   '));
         }
+        if (gen?.rawJson?.response) {
+          log('   [generator] ollama response text (full):');
+          log('   ' + preview(gen.rawJson.response, 2000).replace(/\n/g, '\n   '));
+        }
+        if (gen?.rawJson) {
+          const jsonDisplay = JSON.stringify(gen.rawJson, null, 2);
+          log('   [generator] ollama full JSON:');
+          log('   ' + jsonDisplay.replace(/\n/g, '\n   '));
+        }
       }
     } catch (e) {
       const msg = e?.message || String(e);

src/providers/ollama_provider.mjs

@@ -57,7 +57,7 @@ export class OllamaProvider extends BaseProvider {
    * @param {string} prompt
    * @returns {Promise<string>} the model's response text
    */
-  async generate(prompt) {
+  async generate(prompt, { includeJson = false } = {}) {
     const url = `${this.baseUrl}/api/generate`;
 
     const body = {
@@ -82,6 +82,15 @@ export class OllamaProvider extends BaseProvider {
     }
 
     const data = await res.json();
+
+    if (includeJson) {
+      return {
+        response: data.response ?? '',
+        thinking: data.thinking,
+        fullResponse: data,
+      };
+    }
+
     // Standard Ollama /api/generate response uses `response`
     return data.response ?? '';
   }

tests/try_generator_prompt.test.mjs

@@ -0,0 +1,85 @@
+import { describe, it, expect } from 'vitest';
+import { mkdtempSync, writeFileSync, mkdirSync } from 'fs';
+import { tmpdir } from 'os';
+import path from 'path';
+import { execFileSync } from 'child_process';
+import { chunkIdFromContent } from '../src/pipeline/ids.mjs';
+
+describe('scripts/try_generator_prompt.sh', () => {
+  it('prints the generator response using cached chunk/question', () => {
+    const workdir = mkdtempSync(path.join(tmpdir(), 'try-gen-'));
+    const cacheDir = path.join(workdir, 'cache');
+    mkdirSync(cacheDir, { recursive: true });
+
+    const content = 'Chunk content for testing.';
+    const sourceId = 'source-1';
+    const chunkId = chunkIdFromContent(content, sourceId);
+
+    const questionsFile = path.join(cacheDir, 'questions.jsonl');
+    writeFileSync(
+      questionsFile,
+      JSON.stringify({
+        chunk_id: chunkId,
+        questions: ['What is being asked?'],
+        question_ids: ['q1'],
+        provider: 'mock',
+        model: 'mock',
+        ts: Date.now(),
+      }) + '\n',
+      'utf8',
+    );
+
+    const ragFile = path.join(workdir, 'rag.jsonl');
+    writeFileSync(
+      ragFile,
+      JSON.stringify({ id: sourceId, content }) + '\n',
+      'utf8',
+    );
+
+    const promptFile = path.join(workdir, 'prompt.txt');
+    writeFileSync(
+      promptFile,
+      'Q: {{QUESTION}}\nCTX: {{CONTEXT}}',
+      'utf8',
+    );
+
+    // Mock Ollama response via file://
+    const mockApiDir = path.join(workdir, 'mock-ollama', 'api');
+    mkdirSync(mockApiDir, { recursive: true });
+    const mockResponsePath = path.join(mockApiDir, 'generate');
+    writeFileSync(
+      mockResponsePath,
+      JSON.stringify({ response: 'mock generator answer' }),
+      'utf8',
+    );
+
+    const scriptPath = path.join(
+      path.dirname(new URL(import.meta.url).pathname),
+      '..',
+      'scripts',
+      'try_generator_prompt.sh',
+    );
+
+    const env = {
+      ...process.env,
+      PIPELINE_CACHE_DIR: cacheDir,
+      RAG_CHUNKS_PATH: ragFile,
+      PROMPT_FILE: promptFile,
+      OLLAMA_URL: `file://${path.join(workdir, 'mock-ollama')}`,
+      GENERATOR_MODEL: 'mock-model',
+    };
+
+    let output;
+    try {
+      output = execFileSync('bash', [scriptPath], {
+        env,
+        encoding: 'utf8',
+      });
+    } catch (err) {
+      output = err?.stdout?.toString?.() || '';
+    }
+
+    expect(output).toContain('mock generator answer');
+    expect(output).toContain(chunkId);
+  });
+});