@polylogicai/polycode 1.1.0 → 1.1.2

package/bin/polycode.mjs

@@ -15,10 +15,15 @@ import { computeAgencyReceipt, formatReceipt } from '../lib/agency-receipt.mjs';
 import { fireHook } from '../lib/hooks.mjs';
 import { compilePacket } from '../lib/compiler.mjs';
 import { loadAnthropicKeys, reportKeyStatus } from '../lib/inference-router.mjs';
-import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { randomUUID } from 'node:crypto';
+import { join, dirname, resolve } from 'node:path';
+import { randomUUID, createHash } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PACKAGE_JSON = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
 import * as readline from 'node:readline/promises';
 import { stdin, stdout, exit, argv, env, cwd as getCwd } from 'node:process';
 import 'dotenv/config';
@@ -137,7 +142,7 @@ function loadRules() {
   return {};
 }
 
-const VERSION = '1.1.0';
+const VERSION = PACKAGE_JSON.version;
 const DOCS_URL = 'https://polylogicai.com/polycode';
 
 const BANNER = `${C.bold}${C.amber}polycode v${VERSION}${C.reset}
@@ -173,7 +178,57 @@ function resolveConfigDir() {
   return dir;
 }
 
-async function runOneShot(message, { loop, canon, cwd, renderer, state, sessionId, hookDir }) {
+// Per-working-directory session log scoping. Running polycode from different
+// directories produces different session logs, so history from one project
+// does not contaminate another. The cwd is hashed and the short prefix used
+// as a directory name under ~/.polycode/canon. A cwd.txt file in the scope
+// directory preserves the original path for debugging.
+function resolveScopedCanonFile(configDir, cwd) {
+  const cwdHash = createHash('sha256').update(cwd).digest('hex').slice(0, 12);
+  const scopeDir = join(configDir, 'canon', cwdHash);
+  if (!existsSync(scopeDir)) mkdirSync(scopeDir, { recursive: true });
+  const cwdPointerPath = join(scopeDir, 'cwd.txt');
+  if (!existsSync(cwdPointerPath)) {
+    try { writeFileSync(cwdPointerPath, cwd + '\n'); } catch {}
+  }
+  return join(scopeDir, `${new Date().toISOString().slice(0, 10)}.jsonl`);
+}
+
+// POLYCODE.md project context. On startup, walk up from cwd looking for a
+// project-context file. If found, its content is injected into the agent's
+// system prompt as project context. Supported names in priority order.
+function findPolycodeMd(startDir) {
+  const NAMES = ['POLYCODE.md', 'polycode.md', '.polycode.md'];
+  let dir = resolve(startDir);
+  for (let depth = 0; depth < 20; depth++) {
+    for (const name of NAMES) {
+      const candidate = join(dir, name);
+      try {
+        if (statSync(candidate).isFile()) return candidate;
+      } catch {
+        // not present, try next
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+function loadProjectContext(cwd) {
+  const path = findPolycodeMd(cwd);
+  if (!path) return { content: null, path: null };
+  try {
+    const content = readFileSync(path, 'utf8').slice(0, 8000);
+    return { content, path };
+  } catch {
+    return { content: null, path: null };
+  }
+}
+
+async function runOneShot(message, opts) {
+  const { loop, canon, cwd, renderer, state, sessionId, hookDir } = opts;
   await fireHook('UserPromptSubmit', {
     session_id: sessionId, cwd, hook_event_name: 'UserPromptSubmit', prompt: message,
   }, hookDir);
@@ -188,12 +243,14 @@ async function runOneShot(message, { loop, canon, cwd, renderer, state, sessionI
   state.lastTurnTokens = result.promptTokensUsed;
   state.lastCompiler = result.compilerProvider;
 
-  const receipt = computeAgencyReceipt({
-    primitivesList: result.primitivesList,
-    wallClockMs: result.durationMs,
-    iterations: result.iterations,
-  });
-  stdout.write(`${C.dim}${formatReceipt(receipt)} . ${canon.size()} rows in log${C.reset}\n`);
+  if (opts.verbose) {
+    const receipt = computeAgencyReceipt({
+      primitivesList: result.primitivesList,
+      wallClockMs: result.durationMs,
+      iterations: result.iterations,
+    });
+    stdout.write(`${C.dim}${formatReceipt(receipt)} . ${canon.size()} rows in log${C.reset}\n`);
+  }
 
   await fireHook('Stop', { session_id: sessionId, cwd, hook_event_name: 'Stop' }, hookDir);
   return result;
@@ -202,7 +259,12 @@ async function runOneShot(message, { loop, canon, cwd, renderer, state, sessionI
 async function runRepl(opts) {
   const rl = readline.createInterface({ input: stdin, output: stdout });
   stdout.write(BANNER + '\n');
-  stdout.write(`${C.dim}session log: ${opts.canon.size()} rows . ${opts.canon.lastHash().slice(0, 12)}...${C.reset}\n`);
+  if (opts.projectContextPath) {
+    stdout.write(`${C.dim}project context: ${opts.projectContextPath}${C.reset}\n`);
+  }
+  if (opts.canon.size() > 0) {
+    stdout.write(`${C.dim}session log: ${opts.canon.size()} rows${C.reset}\n`);
+  }
   stdout.write(`${C.dim}type /help for commands. ctrl+c or /exit to leave.${C.reset}\n\n`);
 
   try {
@@ -246,9 +308,11 @@ async function main() {
   const model = env.POLYCODE_MODEL || 'moonshotai/kimi-k2-instruct';
   const cwd = env.POLYCODE_CWD || getCwd();
   const hookDir = env.POLYCODE_HOOK_DIR || join(configDir, 'hooks');
-  const canonFile = env.POLYCODE_CANON_FILE || join(configDir, 'canon', `${new Date().toISOString().slice(0, 10)}.jsonl`);
+  const canonFile = env.POLYCODE_CANON_FILE || resolveScopedCanonFile(configDir, cwd);
+  const verbose = args.includes('--verbose') || args.includes('-V');
 
   const canon = createCanon(canonFile);
+  const { content: projectContext, path: projectContextPath } = loadProjectContext(cwd);
 
   if (args.includes('--history') || args.includes('--log')) {
     stdout.write(`session log: ${canonFile}\nrows: ${canon.size()}\nlast_hash: ${canon.lastHash()}\n`);
@@ -292,10 +356,10 @@ async function main() {
     canon_path: canonFile,
   }, hookDir);
 
-  const loop = new AgenticLoop({ apiKey, model, rules });
-  const renderer = createRenderer(stdout);
+  const loop = new AgenticLoop({ apiKey, model, rules, projectContext });
+  const renderer = createRenderer(stdout, { verbose });
   const state = { lastTurnTokens: 0, lastCompiler: null };
-  const opts = { loop, canon, cwd, renderer, state, sessionId, hookDir };
+  const opts = { loop, canon, cwd, renderer, state, sessionId, hookDir, verbose, projectContextPath };
 
   const positional = args.filter((a) => !a.startsWith('--') && args[args.indexOf(a) - 1] !== '--packet');
   if (positional.length > 0) {

package/lib/agentic.mjs

@@ -23,22 +23,60 @@ const execAsync = promisify(exec);
 
 const DEFAULT_MODEL = 'moonshotai/kimi-k2-instruct';
 const FALLBACK_MODEL = 'llama-3.3-70b-versatile';
-const DEFAULT_MAX_ITERATIONS = 12;
+const DEFAULT_MAX_ITERATIONS = 8;
 const TEMPERATURE = 0.2;
 const MAX_TOKENS = 4096;
 const MAX_BASH_TIMEOUT_MS = 30_000;
 const MAX_OUTPUT_BYTES = 3200;
 
-const SYSTEM_PROMPT = `You are polycode, a terminal coding agent. Each turn you receive the current user message along with a small set of context rows selected from the session log by a separate selection step. You do not need to hold conversation history in your own memory. Produce a short plan and the tool calls needed to address the current message, then call task_done with a one or two sentence summary.
+const SYSTEM_PROMPT_BASE = `You are polycode, a coding assistant that runs in the user's terminal. You help users in three distinct modes. Pick the right mode based on the current user message.
+
+Mode 1: CONVERSATIONAL. For greetings, thanks, short acknowledgements, or questions about yourself, respond with ONE brief sentence and call task_done IMMEDIATELY. Do not use any tools.
+  Examples:
+    User: hello
+    You: Hi. I am polycode. What can I help you with?
+    (call task_done with exactly that text)
+
+    User: thanks
+    You: You're welcome.
+    (call task_done with exactly that text)
+
+    User: who are you
+    You: I am polycode, a coding assistant that runs on your machine with your API keys.
+    (call task_done with exactly that text)
+
+Mode 2: KNOWLEDGE QUESTION. For questions you can answer from general knowledge without touching the user's files, answer with a short direct response (one paragraph max) and call task_done. Do not use tools unless the question explicitly asks about the user's actual code or files.
+  Example:
+    User: what is the difference between let and const in javascript?
+    You: let allows reassignment, const does not. Both are block-scoped. const still allows mutation of object contents.
+    (call task_done with that explanation)
+
+Mode 3: CODE TASK. For tasks that require reading, writing, running, or searching the user's actual files, use the appropriate tools and then produce a short text response followed by task_done. Available tools: bash, read_file, write_file, edit_file, glob, grep.
+  Example:
+    User: read package.json and tell me the main entry
+    You: (call read_file on package.json, then respond with the answer, then task_done)
+
+Hard rules:
+- Always produce a text message in your response. Never call task_done without first saying something to the user.
+- Never loop more than 3 iterations without producing text. If you are not sure what to do, ask the user and call task_done.
+- Do not explore the filesystem unless the user's current message explicitly asks about their files.
+- Do not assume there is an ongoing task from prior turns unless the current message continues it.
+- If a tool call fails, acknowledge the failure in your text response, do not retry the same operation.
+- Use periods, commas, colons. Not em dashes. No hype words.
+
+Verification: every tool call is checked by a deterministic layer before it lands in the session log. Failures are marked REFUTED. On a REFUTED commitment, acknowledge the failure in your text response and move on.`;
+
+function buildSystemPrompt(projectContext) {
+  if (!projectContext || typeof projectContext !== 'string' || !projectContext.trim()) {
+    return SYSTEM_PROMPT_BASE;
+  }
+  return `${SYSTEM_PROMPT_BASE}
 
-Discipline:
-- Use periods, commas, or colons. Not em dashes.
-- No hype words: no "revolutionary", "game-changer", "unprecedented".
-- Read files before asserting their content. Test before claiming something works.
-- Tools available: task_done, bash, read_file, write_file, edit_file, glob, grep.
-- When the current user message has been addressed, call task_done.
+PROJECT CONTEXT (from POLYCODE.md in the user's project):
+${projectContext.slice(0, 6000)}
 
-Every tool call you make is checked by a deterministic verification layer before it is written to the session log. Checks include content grounding, file existence, rule compliance against a forbidden list, and secret scrubbing on tool output. If a check fails, the record is marked REFUTED and you should acknowledge and correct rather than retry the same action.`;
+When answering questions about the project, prefer the information in the PROJECT CONTEXT over reading files, unless the user explicitly asks you to read a file.`;
+}
 
 const TOOL_SCHEMAS = [
   {
@@ -241,11 +279,12 @@ function recoverInlineToolCalls(content) {
 }
 
 export class AgenticLoop {
-  constructor({ apiKey, model, logger, rules } = {}) {
+  constructor({ apiKey, model, logger, rules, projectContext } = {}) {
     this.apiKey = apiKey;
     this.defaultModel = model || DEFAULT_MODEL;
     this.logger = logger || console;
     this.rules = rules || {};
+    this.systemPrompt = buildSystemPrompt(projectContext);
   }
 
   async runTurn({ canon, userMessage, cwd, onEvent, maxIterations }) {
@@ -318,7 +357,7 @@ export class AgenticLoop {
 
     // Phase 3 + Phase 4: DISPATCH and ACT
     const messages = [
-      { role: 'system', content: SYSTEM_PROMPT },
+      { role: 'system', content: this.systemPrompt },
       { role: 'user', content: ctx.prompt },
     ];
 

package/lib/compiler.mjs

@@ -18,6 +18,74 @@ const COMPILER_MODEL = 'claude-haiku-4-5-20251001';
 const COMPILER_MAX_TOKENS = 600;
 const SUMMARY_ROW_LIMIT = 400;
 
+// Conversational fast-path. Short user messages that look like greetings,
+// acknowledgements, or self-questions skip the LLM compile step entirely
+// and use a minimal pure-Node packet. Cuts per-turn latency from ~3s to
+// sub-second for these cases and keeps the LLM from being told to continue
+// any prior task when the user clearly is not asking about one.
+const CONVERSATIONAL_MAX_LEN = 80;
+const CONVERSATIONAL_PATTERNS = [
+  /^hi+\b/i,
+  /^hello\b/i,
+  /^hey\b/i,
+  /^yo\b/i,
+  /^howdy\b/i,
+  /^greetings\b/i,
+  /^thanks?\b/i,
+  /^thank you\b/i,
+  /^thx\b/i,
+  /^ty\b/i,
+  /^ok(ay)?\b/i,
+  /^cool\b/i,
+  /^nice\b/i,
+  /^great\b/i,
+  /^got it\b/i,
+  /^sure\b/i,
+  /^sounds good\b/i,
+  /^good\b/i,
+  /^how are you\b/i,
+  /^how('s| is) it going\b/i,
+  /^what's up\b/i,
+  /^sup\b/i,
+  /^who are you\b/i,
+  /^what are you\b/i,
+  /^what is polycode\b/i,
+  /^what can you do\b/i,
+  /^tell me about yourself\b/i,
+  /^bye\b/i,
+  /^goodbye\b/i,
+  /^see you\b/i,
+  /^later\b/i,
+];
+
+function isConversational(message) {
+  if (!message || typeof message !== 'string') return false;
+  const trimmed = message.trim();
+  if (trimmed.length === 0 || trimmed.length > CONVERSATIONAL_MAX_LEN) return false;
+  return CONVERSATIONAL_PATTERNS.some((re) => re.test(trimmed));
+}
+
+function buildConversationalPacket(userMessage, cwd) {
+  const lines = [
+    `[polycode conversational-fast-path]`,
+    `working_directory: ${cwd || process.cwd()}`,
+    '',
+    `CURRENT USER MESSAGE:`,
+    userMessage,
+    '',
+    `Respond with one short sentence and call task_done immediately. Do not use any tools.`,
+  ];
+  const prompt = lines.join('\n');
+  return {
+    prompt,
+    estimatedTokens: Math.ceil(prompt.length / 4),
+    selectedRows: [],
+    compilerProvider: 'conversational-fast-path',
+    compilerUsage: null,
+    fallback: false,
+  };
+}
+
 const COMPILER_SYSTEM_PROMPT = `You are a context selection helper. You receive a summary of a user's append-only session log (each row has an index, a type, and a short preview) and the user's current message. Your job is to return a JSON list of the row indices most relevant to the current message. You never write prose.
 
 Selection rules:
@@ -83,6 +151,14 @@ async function selectRelevantRows(canon, userMessage) {
 }
 
 export async function compilePacket(canon, userMessage, cwd) {
+  // Fast-path: trivial conversational messages skip the LLM compile step and
+  // get a minimal packet that tells the generator to respond briefly and stop.
+  // This structurally prevents prior-session contamination from poisoning
+  // short greetings and acknowledgements.
+  if (isConversational(userMessage)) {
+    return buildConversationalPacket(userMessage, cwd);
+  }
+
   const selection = await selectRelevantRows(canon, userMessage);
   const selectedIndices = new Set(selection.selected || []);
 

package/lib/repl-ui.mjs

@@ -1,8 +1,9 @@
 // lib/repl-ui.mjs
-// Streaming terminal UI with ANSI colors. Zero external deps.
-// The renderer subscribes to events emitted by AgenticLoop.runTurn() and
-// prints each phase with a colored prefix. The verdict pill is rendered
-// when a commitment is recorded.
+// REPL output renderer. Default mode is compact: show a single collapsed
+// line per tool call, show the agent's text response prominently, hide the
+// internal phase trace. Verbose mode (--verbose) shows every phase, every
+// tool call argument, every tool result preview, every record event.
+// Zero external dependencies; ANSI colors only.
 
 export const C = {
   reset: '\x1b[0m',
@@ -50,10 +51,48 @@ function phasePrefix(name) {
   return map[name] || `${C.gray}. ${name}${C.reset}`;
 }
 
-export function createRenderer(stdout) {
+// Compact-mode tool call renderer. Produces a single line per tool call
+// that names the tool and its most-useful argument, no JSON dump.
+function compactToolCallLine(name, args) {
+  const a = args || {};
+  let arg = '';
+  if (name === 'read_file' || name === 'write_file' || name === 'edit_file') {
+    arg = a.path || '';
+  } else if (name === 'bash') {
+    arg = String(a.command || '').slice(0, 60);
+  } else if (name === 'glob') {
+    arg = a.pattern || '';
+  } else if (name === 'grep') {
+    arg = a.pattern || '';
+    if (a.glob) arg += ` in ${a.glob}`;
+  } else if (name === 'task_done') {
+    return null; // task_done is implicit in the final response, not shown as an action
+  }
+  return `${C.dim}${C.gray}·${C.reset} ${C.bold}${name}${C.reset}${C.dim}${arg ? ` ${arg}` : ''}${C.reset}`;
+}
+
+// Compact-mode tool result renderer. A single short line per result.
+function compactToolResultLine(name, result) {
+  if (name === 'task_done') return null;
+  const r = String(result || '');
+  if (r.startsWith('error:')) {
+    return `${C.dim}${C.red}  ${r.slice(0, 140)}${C.reset}`;
+  }
+  if (r.startsWith('ok:')) {
+    return `${C.dim}${C.green}  ${r.slice(0, 140)}${C.reset}`;
+  }
+  // Default: one-line truncated preview
+  const preview = r.slice(0, 140).replace(/\n/g, ' ');
+  return `${C.dim}  ${preview}${C.reset}`;
+}
+
+export function createRenderer(stdout, opts = {}) {
+  const verbose = Boolean(opts.verbose);
+
   function line(s) { stdout.write(s + '\n'); }
 
-  function onEvent(ev) {
+  // Verbose event handler: shows every phase, tool call, result, record.
+  function onEventVerbose(ev) {
     if (ev.phase === 'intent') {
       line(`${phasePrefix('intent')} ${C.dim}active intent resolved${C.reset}`);
     } else if (ev.phase === 'ground_complete') {
@@ -87,5 +126,30 @@ export function createRenderer(stdout) {
     }
   }
 
-  return { onEvent, C, verdictPill };
+  // Compact event handler: shows tool calls as single-line actions, shows
+  // the agent's text response, hides all internal tracing.
+  function onEventCompact(ev) {
+    if (ev.phase === 'act' && ev.kind === 'message') {
+      const content = String(ev.content || '').trim();
+      if (content) line(`${C.cyan}${content}${C.reset}`);
+    } else if (ev.phase === 'act' && ev.kind === 'tool_call') {
+      const out = compactToolCallLine(ev.name, ev.args);
+      if (out) line(out);
+    } else if (ev.phase === 'act' && ev.kind === 'tool_result') {
+      const out = compactToolResultLine(ev.name, ev.result);
+      if (out) line(out);
+    } else if (ev.phase === 'scrub_blocked') {
+      line(`${C.red}refusing to send tool output to the model: contains a recognized secret pattern${C.reset}`);
+    } else if (ev.phase === 'error') {
+      line(`${C.red}error: ${ev.message}${C.reset}`);
+    }
+    // All other phases hidden in compact mode.
+  }
+
+  return {
+    onEvent: verbose ? onEventVerbose : onEventCompact,
+    verbose,
+    C,
+    verdictPill,
+  };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polylogicai/polycode",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "An agentic coding CLI. Runs on your machine with your keys. Every turn is appended to a SHA-256 chained session log, so your history is auditable, replayable, and portable.",
   "type": "module",
   "main": "bin/polycode.mjs",