jaitus 0.3.7 → 0.3.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaitus",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "description": "Jaitus — a coding agent in your terminal.",
   "type": "module",
   "bin": {

package/src/agent/loop.js

@@ -31,7 +31,7 @@ import { loadContext, loadIgnore, CONTEXT_FILE } from '../project.js';
 import { c, out, write, spinner, glyph } from '../ui.js';
 import { discoverMcpTools } from '../mcp.js';
 import { unifiedDiff } from '../diff.js';
-import { fromResponse, fromGatewayBody } from '../errors.js';
+import { fromResponse, fromGatewayBody, JaitusError } from '../errors.js';
 
 const MAX_ITERATIONS = 1000;
 const STUCK_REPEATS = 4;
@@ -106,6 +106,9 @@ How to work:
 - Run the project's own tests or build after a change when one exists, and report the real result — including when it fails.
 - Use run_command for anything the shell does better: git, tests, package managers, linters.
 - Never invent a file path, a function name, or a test result. If you are unsure, look.
+- Every turn re-sends the whole conversation, so make independent reads, searches and
+  listings together in ONE turn rather than one per turn. Read the part of a large file you
+  need (offset/limit) rather than all of it.
 - For current news or other web facts, report only details grounded in web_search or
   web_fetch output. Include the supplied source URLs; never fill a missing headline or
   date from memory.
@@ -241,7 +244,11 @@ export function repairToolPairs(messages) {
 // at least TRIM_AT_LEAST at a time, because each clearing breaks the prompt cache once
 // — clearing a little on every step would cost more than it saves. Small results (a
 // "file written", an exit code) are kept: they carry meaning and cost nothing.
-export const TRIM_AT = 100_000;         // estimated tokens of conversation (the documented default)
+// 100k was the documented default for 200k-window models. Here the window is up to 1M, so
+// that ceiling was rarely near: production requests averaged 53k tokens and two thirds of
+// all input tokens came from requests over 60k. At 40k a clearing (one cache break, ~17
+// credits on glm-5.3-flash) pays for itself within about ten later requests.
+export const TRIM_AT = 40_000;          // estimated tokens of conversation
 export const KEEP_RECENT = 6;           // latest tool results always kept whole
 export const TRIM_AT_LEAST = 12_000;    // estimated tokens a clearing must free
 const TRIM_MIN_CHARS = 1_500;           // results shorter than this are never cleared
@@ -418,7 +425,12 @@ async function streamTurn({ client, messages, model, system, tools, onText, onTo
       if (streamError) break;
     }
   } catch (e) {
-    if (signal?.aborted || e?.name === 'AbortError') throw e;
+    // Esc is the only abort that reads as an interruption. Any OTHER AbortError —
+    // the request timeout in api.js firing mid-body, a dropped socket — is a `timeout`
+    // JaitusError so the agent loop backs off and retries it (TRANSIENT_CODES) instead
+    // of reporting "Interrupted." for something the user never stopped.
+    if (signal?.aborted) throw e;
+    if (e?.name === 'AbortError') throw new JaitusError({ code: 'timeout', status: 504, message: 'Jaitus took too long to respond. Try again.' });
     // The connection dropped mid-answer. What arrived is kept and continued from; with
     // nothing received yet, the caller retries the request instead.
     if (!blocks.size) throw e;

package/src/agent/permissions.js

@@ -16,7 +16,7 @@
 
 import path from 'node:path';
 import { c, out, askKey, glyph } from '../ui.js';
-import { decide, ruleForCall, broaderRule, DEFAULT_DENY, subjectOf } from './rules.js';
+import { decide, ruleForCall, broaderRule, DEFAULT_DENY, subjectOf, wideAllows } from './rules.js';
 
 export class PermissionDenied extends Error {}
 
@@ -44,6 +44,8 @@ export function createPermissions({
   const api = {
     get mode() { return current; },
     get rules() { return { allow: [...savedAllow], deny: [...savedDeny], session: [...sessionAllow] }; },
+    /** Saved rules that take a whole tool out of the mode's hands (see wideAllows). */
+    get wide() { return wideAllows(savedAllow); },
 
     /** Add a rule. `persist` writes it to settings via onRulesChange. */
     addRule(rule, { persist = false, kind = 'allow' } = {}) {

package/src/agent/rules.js

@@ -206,15 +206,39 @@ export function ruleForCall(toolName, input, cwd) {
   return `${toolName}(${relative && !relative.startsWith('..') ? relative : subject})`;
 }
 
-/** A broader rule, offered beside the exact one: the whole directory, or the tool. */
+/**
+ * A broader rule, offered beside the exact one: the file's directory. Never the whole
+ * tool. "Always allow every run command" used to be the second option on every command
+ * prompt; one click on it saved a rule that approves every command in that folder in
+ * every mode, forever — after which Ask, Auto-edit and Bypass all behaved the same and
+ * nothing on screen said why. A tool-wide rule can still be written on purpose with
+ * `/permissions allow run_command`; it is just never one click away.
+ */
 export function broaderRule(toolName, input, cwd) {
   const subject = subjectOf(toolName, input);
   if (['write_file', 'edit_file', 'read_file', 'read_image', 'list_files'].includes(toolName) && subject) {
     const relative = cwd ? normalise(path.relative(cwd, path.resolve(cwd, subject))) : subject;
     const dir = relative.includes('/') ? relative.slice(0, relative.lastIndexOf('/')) : '';
-    return dir && !dir.startsWith('..') ? `${toolName}(${dir}/**)` : `${toolName}`;
+    if (dir && !dir.startsWith('..')) return `${toolName}(${dir}/**)`;
+  }
+  return ruleForCall(toolName, input, cwd);
+}
+
+/**
+ * Saved allow rules that approve a whole tool — `run_command`, `edit_file(**)` — for the
+ * tools a mode is about. While one exists, the mode no longer decides that tool, so the
+ * mode's label is only half the truth; callers say so beside it.
+ */
+export function wideAllows(allow = []) {
+  const GATED = ['run_command', 'background_run', 'write_file', 'edit_file'];
+  const out = [];
+  for (const rule of allow) {
+    const parsed = typeof rule === 'string' ? parseRule(rule) : rule;
+    if (!parsed || !GATED.includes(parsed.tool)) continue;
+    const p = parsed.pattern;
+    if (p === null || p === '' || p === '*' || p === '**' || p === '**/*') out.push(parsed.source);
   }
-  return `${toolName}`;
+  return out;
 }
 
 /**

package/src/agent/tools.js

@@ -26,6 +26,18 @@ const MAX_READ_LINES = 2_000;
 
 export class ToolError extends Error {}
 
+/**
+ * Keep the start AND the end. For a test run or a build the end is where the failures and
+ * the summary are; cutting from the front kept the noise and threw away the answer.
+ */
+function truncateMiddle(text, limit) {
+  const s = String(text ?? '');
+  if (s.length <= limit) return s;
+  const head = Math.floor(limit / 3);
+  const tail = limit - head;
+  return `${s.slice(0, head)}\n\n[… ${s.length - limit} characters cut from the middle …]\n\n${s.slice(-tail)}`;
+}
+
 function truncate(text, limit = MAX_OUTPUT) {
   const s = String(text ?? '');
   if (s.length <= limit) return s;
@@ -560,8 +572,10 @@ export const TOOLS = [
           // the joined text cut the exit code off the end of any long output, so the
           // model could not tell whether the command had worked.
           const parts = [];
-          const stdout = truncate(out.text().trim(), 40_000);
-          const stderr = truncate(err.text().trim(), 16_000);
+          // 30k in all (the common agent limit for shell output): every later request
+          // re-sends it until it is cleared.
+          const stdout = truncateMiddle(out.text().trim(), 22_000);
+          const stderr = truncateMiddle(err.text().trim(), 8_000);
           if (stdout) parts.push(stdout);
           if (stderr) parts.push(`stderr:\n${stderr}`);
           if (note) parts.push(note);
@@ -832,6 +846,29 @@ export const TOOLS = [
       return `Stopped ${input.id}.`;
     },
   },
+
+  {
+    // The model loads a skill's instructions itself when a task matches one. Only each
+    // skill's one-line description rides along with every request; the body (a few
+    // thousand tokens) is paid for only in conversations that need it.
+    name: 'load_skill',
+    description: 'Load the full instructions of a skill listed under "Skills" in the system prompt. Call it BEFORE starting a task that matches a skill\'s description, then follow what it says.',
+    needsPermission: false,
+    input_schema: {
+      type: 'object',
+      properties: { name: { type: 'string', description: 'The skill name, e.g. frontend-design.' } },
+      required: ['name'],
+    },
+    summarise: (i) => `skill ${i.name}`,
+    async run(input, { cwd }) {
+      const { discoverSkills } = await import('../skills.js');
+      const skills = discoverSkills(cwd || process.cwd());
+      const name = String(input.name || '').replace(/^\//, '').trim();
+      const skill = skills[name];
+      if (!skill) throw new ToolError(`No skill named ${name}. Available: ${Object.keys(skills).join(', ') || 'none'}.`);
+      return `Skill: ${skill.name}\n\n${skill.content}`;
+    },
+  },
 ];
 
 /** The live task list todo_write maintains; the session renders it in the panel. */

package/src/api.js

@@ -10,6 +10,47 @@ import { fromGatewayBody, fromNetwork, JaitusError } from './errors.js';
 
 export class NotSignedIn extends Error {}
 
+// fetch() has no timeout of its own, and the gateway's worst case is minutes of
+// serial failover across provider keys — so a sick window used to pin the CLI on
+// "Working..." forever. Every call below carries its own ceiling: slow becomes a
+// `timeout` JaitusError (retryable by the agent loop, shown with a request id)
+// instead of eternity. The caller's signal (Esc) still wins: it aborts through the
+// same controller, and only a genuine user abort reads as one.
+const MESSAGES_TIMEOUT_MS = 10 * 60 * 1000; // streamed turns can legitimately run minutes
+const API_TIMEOUT_MS = 30 * 1000;           // dashboard calls are small JSON
+
+// Combine an optional caller signal with a timeout into one signal.
+// Manual combine (not AbortSignal.any): .any needs Node 20.3+, this works everywhere.
+function withTimeout(signal, ms) {
+  const ctrl = new AbortController();
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    try { ctrl.abort(new DOMException('Request timed out', 'TimeoutError')); }
+    catch { try { ctrl.abort(); } catch { /* already gone */ } }
+  }, ms);
+  if (timer.unref) timer.unref();
+  const onAbort = () => {
+    clearTimeout(timer);
+    try { ctrl.abort(signal.reason); } catch { try { ctrl.abort(); } catch { /* already gone */ } }
+  };
+  if (signal) {
+    if (signal.aborted) onAbort();
+    else signal.addEventListener('abort', onAbort, { once: true });
+  }
+  return {
+    signal: ctrl.signal,
+    // True only when OUR timer fired. A user abort also lands here as an AbortError,
+    // but signal.aborted is set then — never mistake Esc for a timeout.
+    timedOut: () => timedOut && !signal?.aborted,
+    cleanup: () => { clearTimeout(timer); signal?.removeEventListener?.('abort', onAbort); },
+  };
+}
+
+function timeoutError() {
+  return new JaitusError({ code: 'timeout', status: 504, message: 'Jaitus took too long to respond. Try again.' });
+}
+
 // The context window the gateway last advertised, or null before it has been asked.
 let contextWindowSeen = null;
 export const advertisedContextWindow = () => contextWindowSeen;
@@ -18,7 +59,9 @@ export function createClient() {
   const { baseUrl } = endpoints();
   if (!signedIn()) throw new NotSignedIn('Not signed in. Run `jaitus login` first.');
 
-  const base = { 'Content-Type': 'application/json', 'user-agent': 'jaitus-cli' };
+  // x-jaitus-features: what this build understands, so the gateway can use newer error
+  // codes (a used-up usage window) without an older CLI reading them as "went wrong".
+  const base = { 'Content-Type': 'application/json', 'user-agent': 'jaitus-cli', 'x-jaitus-features': 'usage-window' };
   const headers = (token) => ({ ...base, authorization: `Bearer ${token}` });
 
   return {
@@ -26,45 +69,63 @@ export function createClient() {
 
     /** POST /v1/messages. Returns the raw Response so the caller can stream it. */
     async messages(body, { signal } = {}) {
+      // The timer is deliberately NOT cleared when headers arrive: a stall can happen
+      // mid-body too (headers fast, tokens never come), and only the stream reader ends
+      // that. Aborting a finished request is harmless; the timer never holds the
+      // process open (unref). 10 minutes: streamed agentic turns legitimately run long.
+      const t = withTimeout(signal, MESSAGES_TIMEOUT_MS);
       try {
         return await withAuth((token) => fetch(`${baseUrl}/v1/messages`, {
           method: 'POST',
           headers: headers(token),
           body: JSON.stringify(body),
-          signal,
+          signal: t.signal,
         }));
       } catch (cause) {
-        if (cause?.name === 'JaitusError' || cause?.name === 'AbortError') throw cause;
+        if (cause?.name === 'JaitusError') throw cause;
+        if (t.timedOut()) throw timeoutError();
+        if (cause?.name === 'AbortError') throw cause;
         throw fromNetwork(cause);
       }
     },
 
     /** A dashboard API call, returning parsed JSON. */
     async api(pathname, init = {}) {
+      const t = withTimeout(init.signal, API_TIMEOUT_MS);
       let res;
       try {
         res = await withAuth((token) => fetch(`${baseUrl}/api${pathname}`, {
           ...init,
           headers: { ...headers(token), ...(init.headers || {}) },
+          signal: t.signal,
         }));
+        const body = await res.json().catch(() => ({}));
+        return { ok: res.ok, status: res.status, body };
       } catch (cause) {
         if (cause?.name === 'JaitusError') throw cause;
+        if (t.timedOut()) throw timeoutError();
+        if (cause?.name === 'AbortError') throw cause;
         throw fromNetwork(cause);
+      } finally {
+        t.cleanup();
       }
-      const body = await res.json().catch(() => ({}));
-      return { ok: res.ok, status: res.status, body };
     },
 
     /** Model ids the gateway advertises. */
     async models() {
+      const t = withTimeout(undefined, API_TIMEOUT_MS);
       let res;
       try {
-        res = await withAuth((token) => fetch(`${baseUrl}/v1/models`, { headers: headers(token) }));
+        res = await withAuth((token) => fetch(`${baseUrl}/v1/models`, { headers: headers(token), signal: t.signal }));
       } catch (cause) {
+        t.cleanup();
         if (cause?.name === 'JaitusError') throw cause;
+        if (t.timedOut()) throw timeoutError();
+        if (cause?.name === 'AbortError') throw cause;
         throw fromNetwork(cause);
       }
       const body = await res.json().catch(() => ({}));
+      t.cleanup();
       if (!res.ok) throw fromGatewayBody(res.status, body, { requestId: res.headers.get('x-request-id') || '' });
       const models = (body?.data || []).map((m) => m?.id).filter(Boolean);
       // How much conversation fits, as the gateway computed it for this account.

package/src/errors.js

@@ -18,7 +18,8 @@ const CATALOG = {
   rate_limited: { title: 'Slow down', hint: 'Wait a moment, then retry.' },
   context_too_long: { title: 'Conversation too long', hint: 'Run /compact, or start a new session.' },
   request_too_large: { title: 'Request too large', hint: 'Usually images: remove some, or run /compact to drop old ones. Images over 3.5 MB are shrunk automatically.' },
-  daily_limit_reached: { title: 'Daily limit reached', hint: 'Today\'s credits reset at midnight. /usage shows where you are.' },
+  daily_limit_reached: { title: 'Usage limit reached', hint: 'It refills automatically. /usage shows where you are.' },
+  window_limit_reached: { title: 'This usage window is used up', hint: 'It refills when the window ends — the rest of your month is still there. /usage shows when.' },
   token_expired: { title: 'Signed out', hint: 'Type /login to sign in again (or run `jaitus login`).' },
   refresh_race: { title: 'Sign-in was being renewed', hint: 'Try again.' },
   content_blocked: { title: 'Request refused', hint: 'Rephrase the request and try again.' },

package/src/index.js

@@ -17,7 +17,7 @@ import {
   endpoints, version, HOME, HISTORY,
 } from './config.js';
 import { runAgent, repairToolPairs } from './agent/loop.js';
-import { createPermissions } from './agent/permissions.js';
+import { createPermissions, MODES as PERMISSION_MODES } from './agent/permissions.js';
 import { DEFAULT_DENY } from './agent/rules.js';
 import { forgetIgnoreCache, imageBlock, IMAGE_MIME } from './agent/tools.js';
 import { shrinkImageFile } from './tui/clipboard.js';
@@ -372,6 +372,11 @@ async function loadContextBudget(client) {
 // Compact at this fraction of the budget. Low enough that the summarisation request
 // itself still fits comfortably, high enough that a normal session never sees it.
 const AUTO_COMPACT_AT = 0.78;
+// The budget is what the gateway advertises — the providers' limit, or the admin's
+// Context cap when it is lower (Admin → Settings → Plans & credits). That cap is the ONE
+// control for how big a session gets before it is summarised: a second ceiling here
+// would silently override whatever the admin set.
+const compactThreshold = () => CONTEXT_BUDGET * AUTO_COMPACT_AT;
 
 // An expanded @mention is capped: pulling a 4 MB lockfile into the prompt because
 // someone typed `@package-lock.json` would blow the context it is meant to save.
@@ -421,8 +426,20 @@ async function summarise(client, model, messages, focus) {
     messages: [
       {
         role: 'user',
-        content: 'Summarize this conversation compactly for a successor agent: what was asked, '
-          + 'what was done (files changed, commands run, outcomes), what remains. Be specific and terse.'
+        // Sections a successor needs to carry on without re-asking or re-reading — the
+        // same structure agent tools use for their own compaction. Losing the user's
+        // exact instructions or where the work stopped is what makes a compacted session
+        // feel worse; everything else can be re-read from disk.
+        content: 'Summarize this conversation for a successor agent that will continue the work with no other memory of it. '
+          + 'Use these headings, and be specific (paths, names, numbers) rather than general:\n'
+          + '1. Request — what the user asked for, with their exact words for any instruction, constraint or preference.\n'
+          + '2. Corrections — anything the user rejected, corrected or asked to do differently, verbatim where short.\n'
+          + '3. Files — every file read or changed: path, what changed or what matters in it.\n'
+          + '4. Commands and results — what was run and what it showed (test/build results, errors and how each was fixed).\n'
+          + '5. Decisions — what was chosen and why.\n'
+          + '6. Current state — exactly what was being done when this summary was made, and what is unfinished.\n'
+          + '7. Next step — the single next action, if the work was mid-way.\n'
+          + 'Omit headings that have nothing. No preamble.'
           + (focus ? ` Focus on: ${focus}.` : '')
           + `\n\n<conversation>\n${transcriptForSummary(messages)}\n</conversation>`,
       },
@@ -502,6 +519,37 @@ function projectRules(cwd) {
   return { allow: Array.isArray(saved.allow) ? saved.allow : [], deny: Array.isArray(saved.deny) ? saved.deny : [] };
 }
 
+/** The bypass confirmation, wherever bypass is switched on from. */
+const BYPASS_CHOICES = [
+  { label: 'Yes, for this session', value: 'y' },
+  { label: 'Yes, and start every new session in bypass', value: 'always' },
+  { label: 'No, stay put', value: 'n' },
+];
+const BYPASS_WARNING = [
+  'Writes and shell commands will run with NO permission prompts.',
+  'Use only in a trusted workspace you can afford to rebuild. Deny rules still apply.',
+];
+
+/** The mode every new session starts in; null goes back to "the last one used". */
+function saveDefaultMode(mode) {
+  const settings = loadSettings();
+  if (mode) settings.defaultMode = mode;
+  else delete settings.defaultMode;
+  saveSettings(settings);
+}
+
+/**
+ * What to say beside a mode when a saved rule already approves a whole tool here —
+ * otherwise "Ask" is on screen while every command runs unasked, and the modes look
+ * like they do nothing.
+ */
+function wideRuleNote(permissions, mode) {
+  if (mode === 'plan' || mode === 'bypassPermissions') return '';
+  const wide = permissions?.wide || [];
+  if (!wide.length) return '';
+  return `Saved rule ${wide.join(', ')} skips the permission question in every mode here — /permissions forget ${wide[0]} to let the mode decide.`;
+}
+
 /** The key rules are saved under: the existing spelling when there is one. */
 function rulesKey(cwd) {
   return Object.keys(loadSettings().permissionRules || {}).find((k) => sameDir(k, cwd)) || path.resolve(cwd);
@@ -547,8 +595,11 @@ async function oneShot(task, { flags }) {
   messages.push({ role: 'user', content: task });
 
   const explicitPlan = flags.permissionModeExplicit && flags.permissionMode === 'plan';
+  // The saved default mode applies here too — "every session" includes `jaitus -p`.
+  const savedDefault = loadSettings().defaultMode;
+  const oneShotMode = !flags.permissionModeExplicit && PERMISSION_MODES.includes(savedDefault) ? savedDefault : flags.permissionMode;
   const permissions = createPermissions({
-    autoApprove: flags.yes && !explicitPlan, mode: flags.permissionMode,
+    autoApprove: flags.yes && !explicitPlan, mode: oneShotMode,
     interactive: false, ...projectRules(flags.cwd),
   });
 
@@ -558,7 +609,7 @@ async function oneShot(task, { flags }) {
       ...(flags.maxTurns ? { maxIterations: flags.maxTurns } : {}),
       silent: true,
       systemOverride: flags.systemPrompt || null,
-      extraSystem: flags.appendSystemPrompt ? `\n\nAdditional instructions:\n${flags.appendSystemPrompt}` : '',
+      extraSystem: `${skillCatalog(discoverSkills(flags.cwd))}${flags.appendSystemPrompt ? `\n\nAdditional instructions:\n${flags.appendSystemPrompt}` : ''}`,
       onText: (text) => {
         answer += text;
         if (format === 'stream-json') out(JSON.stringify({ type: 'content_block_delta', delta: { text } }));
@@ -613,7 +664,7 @@ const SLASH = {
   '/tasks': { summary: 'review tool activity from this session' },
   '/image <path>': { summary: 'attach an image (png/jpg/gif/webp) the model will see with your next message' },
   '/memory [text]': { summary: 'show or append to JAITUS.md (# does this inline)' },
-  '/permissions [mode|rules]': { summary: 'permission mode, and the allow/deny rules for this project' },
+  '/permissions [mode|rules|default]': { summary: 'permission mode, the mode new sessions start in, and the allow/deny rules for this project' },
   '/skills': { summary: 'list project workflows' },
   '/sessions': { summary: 'list saved sessions in this directory' },
   '/session': { summary: 'show this session id', hidden: true },  // the id is already in /status
@@ -778,11 +829,21 @@ async function session({ flags }) {
   // flag used to be overridden by it, so after one Shift+Tab `--permission-mode plan`
   // started a session that edited files without asking. Plan (often set by /ask or
   // /plan, not chosen) and bypass never carry into a new session on their own.
-  const lastMode = loadSettings().lastMode;
-  if (lastMode && !flags.yes && !flags.permissionModeExplicit && ['default', 'acceptEdits'].includes(lastMode)) permissions.setMode(lastMode);
+  // A saved default mode (`/permissions default <mode>`, or "Yes, every session" on the
+  // bypass prompt) is a choice made once, on purpose, and it wins over the last mode:
+  // turning bypass on in every new chat was the thing people had to repeat.
+  const startSettings = loadSettings();
+  const defaultMode = PERMISSION_MODES.includes(startSettings.defaultMode) ? startSettings.defaultMode : null;
+  const lastMode = startSettings.lastMode;
+  if (!flags.yes && !flags.permissionModeExplicit) {
+    if (defaultMode) permissions.setMode(defaultMode);
+    else if (['default', 'acceptEdits'].includes(lastMode)) permissions.setMode(lastMode);
+  }
+  const bypassIsDefault = defaultMode === 'bypassPermissions' && !flags.permissionModeExplicit;
   // Starting straight into bypass gets one explicit confirmation (§11) when a
-  // human is present; headless runs just get the warning on stderr.
-  if (permissions.mode === 'bypassPermissions' && !flags.yes) {
+  // human is present; headless runs just get the warning on stderr. A saved bypass
+  // default was confirmed when it was saved and is not asked again.
+  if (permissions.mode === 'bypassPermissions' && !flags.yes && !bypassIsDefault) {
     if (process.stdin.isTTY && process.stdout.isTTY) {
       out(`\n  ${c.red(c.bold('● BYPASS'))} ${c.red('requested — writes and shell commands would run with no permission checks.')}`);
       const answer = await askKey(`  ${c.dim(`Enable bypass mode for this session? [y/N] ${glyph('›', '>')}`)} `, ['y', 'n', '\r', ' ']);
@@ -873,17 +934,15 @@ async function session({ flags }) {
       const order = ['default', 'acceptEdits', 'plan', 'bypassPermissions'];
       const next = order[(order.indexOf(permissions.mode) + 1) % order.length];
       if (next === 'bypassPermissions') {
-        const ans = await tui.askDialog('Enable bypass mode?', [
-          { label: 'Yes, skip all checks', value: 'y' },
-          { label: 'No, stay put', value: 'n' },
-        ], [
-          'Writes and shell commands will run with NO permission prompts.',
-          'Use only in a trusted workspace you can afford to rebuild.',
-        ]);
-        if (dialogValue(ans) !== 'y') return permissions.mode;
+        const ans = await tui.askDialog('Enable bypass mode?', BYPASS_CHOICES, BYPASS_WARNING);
+        const picked = dialogValue(ans);
+        if (picked !== 'y' && picked !== 'always') return permissions.mode;
+        if (picked === 'always') saveDefaultMode('bypassPermissions');
       }
       const m = permissions.cycleMode();
       refreshStatusLine('mode');
+      const note = wideRuleNote(permissions, m);
+      if (note) tui.flash?.(note, 'warn', 4500);
       return m;
     },
   };
@@ -1109,7 +1168,7 @@ async function session({ flags }) {
   const autoCompactIfNeeded = async () => {
     if (loadSettings().autoCompact === false) return;
     const used = estimateTokens(messages);
-    if (used < CONTEXT_BUDGET * AUTO_COMPACT_AT) return;
+    if (used < compactThreshold()) return;
     if (messages.length < 4) return;
 
     tui.setStatus?.(`Compacting — ${format(used)} of ${format(CONTEXT_BUDGET)} context used`);
@@ -1426,6 +1485,15 @@ async function session({ flags }) {
     showContext();
     tui.setSpent?.(spent);
     refreshStatusLine('start');
+    // Why the session is in the mode it is in, when that is not obvious from the badge.
+    const startNotes = [
+      bypassIsDefault && permissions.mode === 'bypassPermissions' ? 'Bypass is your default for new sessions — /permissions default ask turns that off.' : '',
+      wideRuleNote(permissions, permissions.mode),
+    ].filter(Boolean);
+    // The welcome screen hides transcript notices until the first message, so the status
+    // line carries them at start; the notice keeps the record in the transcript.
+    for (const note of startNotes) { if (tui.notice) tui.notice(note, 'warn'); else tui.print(c.yellow(`  ${note}`)); }
+    if (startNotes.length) tui.flash?.(startNotes.join('  ·  '), 'warn', 9000);
 
     /** Esc+Esc: pick a checkpoint, restore the conversation and the files. */
     const doRewind = async () => {
@@ -1891,17 +1959,15 @@ async function slashCommand(verb, args, ctx) {
       const applyMode = async (next) => {
         const real = next === 'auto' ? 'bypassPermissions' : next;
         if ((real === 'bypassPermissions') && ctx.tui && ctx.permissions.mode !== 'bypassPermissions') {
-          const ans = await ctx.tui.askDialog('Enable bypass mode?', [
-            { label: 'Yes, skip all checks', value: 'y' },
-            { label: 'No, stay put', value: 'n' },
-          ], [
-            'Writes and shell commands will run with NO permission prompts.',
-            'Use only in a trusted workspace you can afford to rebuild.',
-          ], { title: 'Bypass mode', hideComment: true });
-          if (dialogValue(ans) !== 'y') { info(`Staying in ${c.bold(ctx.permissions.mode)}.`); return; }
+          const ans = await ctx.tui.askDialog('Enable bypass mode?', BYPASS_CHOICES, BYPASS_WARNING, { title: 'Bypass mode', hideComment: true });
+          const picked = dialogValue(ans);
+          if (picked !== 'y' && picked !== 'always') { info(`Staying in ${c.bold(ctx.permissions.mode)}.`); return; }
+          if (picked === 'always') { saveDefaultMode('bypassPermissions'); ok('Bypass is now the default for every new session — /permissions default ask undoes it.'); }
         }
         ctx.permissions.setMode(real);
         ok(`Permission mode: ${c.bold(next)}`);
+        const note = wideRuleNote(ctx.permissions, real);
+        if (note) warn(note);
         if (real === 'bypassPermissions') warn('The agent will not ask before writing files or running commands.');
         if (next === 'plan') info('The agent can read and think, but nothing runs until you switch out of plan mode.');
       };
@@ -1910,6 +1976,27 @@ async function slashCommand(verb, args, ctx) {
       // shows what has accumulated, which matters because "always allow" writes to
       // disk and a list nobody can read is a list nobody can revoke.
       const next = args[0];
+      // ── the mode every new session starts in ──
+      if (next === 'default' && args.length > 1 || next === 'startup') {
+        const wanted = normaliseMode(args[1]) || (/^(off|none|last|unset)$/i.test(args[1] || '') ? 'off' : null);
+        if (!wanted) {
+          const current = loadSettings().defaultMode;
+          info(`New sessions start in ${c.bold(current || 'the last mode used (ask or auto-edit)')}.`);
+          info(`${c.dim('Change it with')} ${c.bold('/permissions default bypass')}${c.dim(', ask, acceptEdits, plan — or off.')}`);
+          return null;
+        }
+        if (wanted === 'bypassPermissions' && ctx.tui && loadSettings().defaultMode !== 'bypassPermissions') {
+          const ans = await ctx.tui.askDialog('Start every new session in bypass?', [
+            { label: 'Yes, every session', value: 'y' },
+            { label: 'No', value: 'n' },
+          ], BYPASS_WARNING, { title: 'Bypass mode', hideComment: true });
+          if (dialogValue(ans) !== 'y') { info('Unchanged.'); return null; }
+        }
+        saveDefaultMode(wanted === 'off' ? null : wanted);
+        ok(wanted === 'off' ? 'New sessions start in the last mode used (ask or auto-edit).' : `New sessions start in ${c.bold(wanted)}.`);
+        if (wanted !== 'off' && ctx.permissions.mode !== wanted) info(`This session stays in ${c.bold(ctx.permissions.mode)} — Shift+Tab or /permissions ${wanted} to switch now.`);
+        return null;
+      }
       if (next === 'rules' || next === 'allow' || next === 'deny' || next === 'forget') {
         const { parseRule } = await import('./agent/rules.js');
         if (next === 'rules') {
@@ -1942,8 +2029,10 @@ async function slashCommand(verb, args, ctx) {
       }
 
       if (next) {
-        if (!Object.keys(MODES).concat('auto').includes(next)) { warn(`Unknown mode: ${next}. Try a mode, or ${c.bold('/permissions rules')}.`); return null; }
-        await applyMode(next);
+        // `bypass`, `ask`, `auto-edit` are what the badge says; they are modes too.
+        const named = normaliseMode(next);
+        if (!named) { warn(`Unknown mode: ${next}. Try ask, acceptEdits, plan, bypass — or ${c.bold('/permissions rules')}.`); return null; }
+        await applyMode(named);
         return null;
       }
       if (!ctx.tui) {
@@ -2601,7 +2690,12 @@ function planRows(u) {
   if (st?.monthlyCredits) {
     const resets = st.periodResetsAt ? ` · resets ${new Date(st.periodResetsAt).toLocaleDateString()}` : '';
     rows.push(['This period', `${cr(st.periodCredits)} of ${cr(st.monthlyCredits)} credits${resets}`]);
-    if (st.dailyCredits) rows.push(['Today', `${cr(st.todayCredits)} of ${cr(st.dailyCredits)} credits · resets at midnight`]);
+    if (st.windowCredits) {
+      const refill = st.windowResetsAt
+        ? `refills at ${new Date(st.windowResetsAt).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })}`
+        : 'opens with your next request';
+      rows.push([`This ${st.windowHours || 5}h window`, `${cr(st.windowUsed)} of ${cr(st.windowCredits)} credits · ${refill}`]);
+    }
     if (st.periodTokens) rows.push(['Behind them', `${fmtTokens(st.periodTokens)} tokens of input and replies`]);
   }
   if (u.planExpiresAt) rows.push(['Renews by', new Date(u.planExpiresAt).toLocaleDateString()]);
@@ -2755,9 +2849,10 @@ const commands = {
       'jaitus config theme <name>       dark, light, ocean, daltonized, auto',
       'jaitus config <key> --unset      back to the default',
       'jaitus config copyOnSelect <on|off>   auto-copy mouse selection',
+      'jaitus config defaultMode bypass      start every session in bypass (ask, acceptEdits, plan; --unset = last mode used)',
     ],
     detail: [
-      'Settable: model, baseUrl, siteUrl, theme, copyOnSelect, scrollSpeed, wheelAccel, autoScroll, animations, autoCompact, trimToolResults, mouse, statusLine,',
+      'Settable: model, baseUrl, siteUrl, theme, defaultMode, copyOnSelect, scrollSpeed, wheelAccel, autoScroll, animations, autoCompact, trimToolResults, mouse, statusLine,',
       'braveSearchKey, tavilyKey, serperKey. Stored in ~/.jaitus/settings.json.',
       '',
       'A search API key is the single biggest improvement available to web_search: the free',
@@ -2781,6 +2876,7 @@ const commands = {
           website: e.siteUrl,
           model: settings.model || null,
           theme: settings.theme || 'auto',
+          defaultMode: settings.defaultMode || null,
           statusLine: settings.statusLine || null,
           copyOnSelect: settings.copyOnSelect !== false,
           scrollSpeed: settings.scrollSpeed ?? 1,
@@ -2800,13 +2896,14 @@ const commands = {
           ['Website', data.website],
           ['Model', data.model || 'whatever the gateway lists first'],
           ['Theme', `${data.theme} (${[...THEME_NAMES, 'auto'].join(', ')})`],
+          ['Start mode', data.defaultMode || 'the last mode used (ask or auto-edit)'],
           ['Copy on select', data.copyOnSelect ? 'on (drag selects, auto-copies)' : 'off (Ctrl+Shift+C copies)'],
           ['Scroll speed', String(data.scrollSpeed)],
           ['Wheel accel', data.wheelAccel ? 'on' : 'off'],
           ['Auto-scroll', data.autoScroll ? 'on' : 'off'],
           ['Animations', data.animations ? 'on' : 'off'],
-          ['Auto-compact', data.autoCompact ? 'on (summarises near the context limit)' : 'off'],
-          ['Trim old tool output', data.trimToolResults ? 'on (clears old outputs past ~100k tokens, keeps the last 6)' : 'off'],
+          ['Auto-compact', data.autoCompact ? 'on (summarises at 78% of the context size the service allows)' : 'off'],
+          ['Trim old tool output', data.trimToolResults ? 'on (clears old outputs past ~40k tokens, keeps the last 6)' : 'off'],
           ['Mouse', data.mouse ? 'on (wheel scrolls, clicks act, drag or double-click copies)' : 'off (the terminal selects text itself)'],
           ['Search API', data.searchApi ? `${data.searchApi} (set)` : 'none — using free engines + npm/GitHub/MDN/Stack Overflow'],
           ['Status line', data.statusLine || '(unset — set a command to render one)'],
@@ -2814,13 +2911,13 @@ const commands = {
         ]));
         return 0;
       }
-      if (!['model', 'baseUrl', 'siteUrl', 'theme', 'statusLine', ...ONOFF, ...SECRET, 'scrollSpeed'].includes(key)) {
-        fail(`Unknown setting: ${key}. Try model, baseUrl, siteUrl, theme, statusLine, ${ONOFF.join(', ')}, ${SECRET.join(', ')} or scrollSpeed.`);
+      if (!['model', 'baseUrl', 'siteUrl', 'theme', 'defaultMode', 'statusLine', ...ONOFF, ...SECRET, 'scrollSpeed'].includes(key)) {
+        fail(`Unknown setting: ${key}. Try model, baseUrl, siteUrl, theme, defaultMode, statusLine, ${ONOFF.join(', ')}, ${SECRET.join(', ')} or scrollSpeed.`);
         return 1;
       }
       // Clearing a value (there was no way: an empty value just printed the current one).
       if (unset) {
-        if (!['model', 'baseUrl', 'siteUrl', 'statusLine', 'theme', 'scrollSpeed', ...SECRET].includes(key)) { fail(`${key} is on/off — set it with on or off.`); return 1; }
+        if (!['model', 'baseUrl', 'siteUrl', 'statusLine', 'theme', 'defaultMode', 'scrollSpeed', ...SECRET].includes(key)) { fail(`${key} is on/off — set it with on or off.`); return 1; }
         delete settings[key];
         saveSettings(settings);
         ok(`${key} cleared — back to the default.`);
@@ -2836,6 +2933,15 @@ const commands = {
         if (key === 'scrollSpeed') { out(String(settings.scrollSpeed ?? 1)); return 0; }
         out(String(settings[key] ?? '')); return 0;
       }
+      if (key === 'defaultMode') {
+        const mode = normaliseMode(value);
+        if (!mode) { fail('Use ask, acceptEdits, plan or bypass (or --unset for the last mode used).'); return 1; }
+        settings.defaultMode = mode;
+        saveSettings(settings);
+        ok(`defaultMode = ${mode} — every new session starts in it`);
+        if (mode === 'bypassPermissions') warn('Writes and shell commands will run with no permission prompts in every session. Deny rules still apply.');
+        return 0;
+      }
       if (key === 'theme') {
         // The themes that exist (ocean was refused; plain was accepted and did nothing).
         const names = [...THEME_NAMES, 'auto'];

package/src/skills/builtin/documents/SKILL.md

@@ -0,0 +1,91 @@
+---
+description: Load BEFORE making a PDF or any printable/shareable document — report, proposal, invoice, resume/CV, letter, certificate, brochure, one-pager, handout, slide deck. Produces typeset, professional documents instead of plain text dumps.
+---
+
+# Professional documents and PDFs
+
+The reliable route is: **write semantic HTML with print CSS, then print it to PDF with a
+headless browser.** It gives real typography, exact page control and is easy to revise.
+Use a PDF library (reportlab, pdfkit, jsPDF) only if the project already uses one.
+
+## 1. Plan the document
+
+- What is it, who reads it, and what must they do after reading? Put that first.
+- Pick a document direction that fits: corporate report (clean sans, blue-black ink, one
+  accent, data tables) · editorial/proposal (serif body, generous margins, pull quotes) ·
+  modern minimal (one sans, lots of white, strong headings) · formal letter/certificate
+  (centred serif, restrained ornament) · resume (dense but calm, two-column, no graphics
+  that ATS software cannot read).
+- Outline the sections before writing; every page should have one clear purpose.
+
+## 2. Page setup (print CSS)
+
+```css
+@page { size: A4; margin: 20mm 18mm 22mm; }            /* or: size: Letter; */
+@page :first { margin-top: 0; }                          /* full-bleed cover if wanted */
+html { -webkit-print-color-adjust: exact; print-color-adjust: exact; }
+body { font: 10.5pt/1.55 "Source Serif 4", Georgia, serif; color: #1b1d22; }
+h1, h2, h3 { font-family: "Inter Tight", "Helvetica Neue", Arial, sans-serif; line-height: 1.15; break-after: avoid; }
+h2 { break-before: auto; margin: 18pt 0 6pt; }
+table, figure, blockquote, .card { break-inside: avoid; }
+p { orphans: 3; widows: 3; }
+.page-break { break-before: page; }
+a { color: inherit; text-decoration: none; border-bottom: 0.5pt solid currentColor; }
+```
+
+- Use pt/mm for print, never viewport units. Body 10–11.5pt, headings on a scale
+  (e.g. 10.5 · 13 · 16 · 22 · 32pt). Line length ~65–80 characters; wide pages use two
+  columns (`columns: 2; column-gap: 8mm;`) or a wide margin column for notes.
+- Colour: dark ink on white, ONE accent colour for headings rules, key numbers and table
+  headers, tinted greys for secondary text. Keep it printable in greyscale.
+- Page numbers / running footer: put a footer element on each page section, or when the
+  browser supports it use `@page { @bottom-right { content: counter(page) " / " counter(pages); } }`.
+
+## 3. Typesetting details that make it look professional
+
+- A proper cover or title block: title, subtitle, author/organisation, date — aligned to a
+  grid, not just a big centred heading.
+- Consistent vertical rhythm: spacing in multiples of the body line height.
+- Tables: left-align text, right-align numbers with tabular figures
+  (`font-variant-numeric: tabular-nums`), light horizontal rules only, a bold or tinted
+  header row, units in the header, totals row emphasised. No full grid of borders.
+- Numbers: thousands separators, consistent decimals, currency symbols (₹ 1,49,900 for
+  Indian format when the audience is Indian).
+- Callouts/key figures as a small highlighted block, not colourful boxes everywhere.
+- Charts: inline SVG (or Chart.js rendered before printing) with direct labels, no 3D, no
+  heavy gridlines, the accent colour for the series that matters and grey for the rest.
+- Real content — no lorem ipsum, no "[Your Name]" left in unless it is a template.
+- Invoices: seller/buyer blocks, invoice number, dates, line items table, tax lines, total,
+  payment details and terms — every legally expected field for the country.
+- Resumes: name large, contact on one line, sections in a clear order, consistent date
+  alignment on the right, verbs and numbers in bullets, one page unless senior.
+
+## 4. Render to PDF
+
+Save the HTML (e.g. `report.html`) and print it with whichever browser is installed:
+
+```sh
+# Windows (Edge ships with Windows)
+"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe" --headless --disable-gpu --no-pdf-header-footer --print-to-pdf="report.pdf" "file:///C:/path/to/report.html"
+# Chrome (any OS)
+chrome --headless --disable-gpu --no-pdf-header-footer --print-to-pdf=report.pdf file:///abs/path/report.html
+# macOS Chrome
+"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --headless --no-pdf-header-footer --print-to-pdf=report.pdf file:///abs/path/report.html
+```
+
+If the project has Node and Playwright or Puppeteer, `page.pdf({ format: 'A4',
+printBackground: true, preferCSSPageSize: true })` works the same. Web fonts must finish
+loading before printing — with a headless browser add `--virtual-time-budget=5000`, or
+embed the fonts locally.
+
+## 5. Check before handing over
+
+1. The PDF exists and opens; report its path and page count.
+2. No heading stranded at the bottom of a page, no table row split, no blank last page.
+3. Margins are even, nothing clipped at the edges, backgrounds printed.
+4. Hierarchy is obvious at a glance; one accent colour; consistent spacing.
+5. All placeholder text replaced; numbers, dates and names are correct.
+
+For slide decks: one idea per slide, 16:9 (`@page { size: 297mm 167mm; margin: 0 }` with
+one `section` per slide), a big headline that states the point, at most ~30 words of body,
+visual consistency across slides, and slide numbers.

package/src/skills/builtin/frontend-design/SKILL.md

@@ -0,0 +1,102 @@
+---
+description: Load BEFORE building or restyling anything people look at — a website, landing page, web app screen, dashboard, component, HTML email, or any HTML/CSS/React/Vue/Svelte UI. Makes it look designed and professional instead of generic.
+---
+
+# Designing interfaces that look made by a designer
+
+The default look of generated UI is instantly recognisable and reads as cheap: a blue or
+purple gradient hero, Inter or system font everywhere, three identical rounded cards with
+emoji icons, grey text on white, soft shadows on everything, centred everything. Avoid all
+of it. Every screen must look like a deliberate choice by someone with taste.
+
+## 1. Decide the direction before writing code
+
+Write these down (in your head or a comment) first — they drive every later decision:
+
+- **Who it is for and what it must make them feel** (trust, speed, calm, delight, authority).
+- **One visual direction**, named concretely. Pick what suits the subject, e.g.:
+  editorial (serif display, generous whitespace, rules and columns) · Swiss/International
+  (strict grid, one sans, big type, flat colour) · warm product (off-white paper, soft ink,
+  one saturated accent) · dark technical (near-black, luminous accent, mono details) ·
+  brutalist (raw borders, heavy type, no radius) · luxury (restrained, large margins, thin
+  serif, muted palette) · playful (bold colour blocks, chunky type, big radius).
+- **The one memorable thing** — an oversized headline, an unusual colour, a striking
+  layout, a detail. A design with nothing memorable is the generic one.
+
+If the project already has a design system, tokens, a brand colour or a component library,
+**follow it** — consistency beats novelty. Read the existing CSS/theme files first.
+
+## 2. Tokens first
+
+Define design tokens as CSS custom properties (or the theme file of the framework in use)
+before any component, and use only them afterwards:
+
+- **Colour:** a background, a surface, 2–3 text shades, ONE accent, borders, and semantic
+  success/warning/danger. Neutrals should be tinted toward the accent's hue (warm or cool
+  greys), never flat `#808080`. Avoid pure `#000` on pure `#fff` for large areas — use ink
+  like `#16181d` on paper like `#faf8f5`. Accent used sparingly: buttons, links, one
+  highlight. Check contrast: body text ≥ 4.5:1, large text ≥ 3:1.
+- **Type:** two families at most — a characterful display face and a readable text face
+  (or one family with strong weight contrast). Good free pairs (Google Fonts):
+  Fraunces + Inter Tight · Instrument Serif + Geist · Space Grotesk + IBM Plex Sans ·
+  DM Serif Display + DM Sans · Playfair Display + Source Sans 3 · JetBrains Mono for code.
+  A modular scale (e.g. 1.25): 12 · 14 · 16 · 20 · 25 · 31 · 39 · 49 · 61. Headlines tight
+  (line-height 1.05–1.15, letter-spacing −0.01 to −0.03em); body 1.5–1.65; measure
+  60–75 characters. Use weight and size for hierarchy, not colour alone.
+- **Space:** a 4 or 8px scale (4 8 12 16 24 32 48 64 96 128). Be generous — cramped is the
+  most common amateur tell. Sections breathe with 96–160px vertical padding on desktop.
+- **Radius and elevation:** choose one radius personality (0, 4–6, or 12–16) and keep it.
+  Prefer borders and background shifts over shadows; when shadows are used, make them
+  subtle and layered (`0 1px 2px rgb(0 0 0 / .06), 0 8px 24px rgb(0 0 0 / .06)`).
+
+## 3. Layout
+
+- Build on a real grid (12 columns, or a clear 2–3 column system) with a max content width
+  (1120–1280px) and consistent gutters.
+- Break symmetry on purpose: asymmetric hero (text left, visual right, offset), a wide
+  feature next to narrow ones, a pull quote, a full-bleed band. Not every section centred.
+- Establish hierarchy in every section: one thing clearly first, then second, then detail.
+- Align everything to the grid; mismatched left edges look broken.
+- Mobile first-class: stack sensibly, keep 16–20px side padding, tap targets ≥ 44px, no
+  horizontal scroll. Test at 375px and 1440px widths mentally or in a browser.
+
+## 4. Components and detail
+
+- **Buttons:** one primary style (solid accent), one secondary (outline or ghost); clear
+  hover, focus-visible (a visible ring), active and disabled states. Label with verbs.
+- **Icons:** one consistent SVG set (Lucide, Heroicons, Phosphor, Tabler) at one stroke
+  weight — never emoji as icons.
+- **Imagery:** real content or tasteful placeholders — CSS/SVG shapes, a gradient mesh used
+  subtly, product mock frames. Never broken image links or stock-photo clichés.
+- **Copy:** specific and concrete; no "Lorem ipsum", no "Welcome to our website", no
+  "Revolutionize your workflow". Real numbers and nouns.
+- **States:** empty, loading (skeletons that match the layout), error (says what happened
+  and what to do), success. Forms: labels above inputs, helpful inline errors.
+- **Motion:** small and purposeful — 150–250ms ease-out for hover/press, a staggered fade-up
+  on first view at most. Respect `prefers-reduced-motion`.
+- **Dark mode** if the product warrants it: redefine the tokens, don't invert colours; dark
+  surfaces are dark grey (`#111318`), not black, with slightly desaturated accents.
+
+## 5. Things that make it look generic — don't
+
+- Purple/blue gradient backgrounds, gradient text on everything, glowing blobs by default.
+- Three equal cards with an emoji, a bold title and two lines of grey text as the main idea.
+- Every section centred with the same padding and the same card component.
+- Default Tailwind blue (`blue-500`) or Bootstrap primary as the brand colour.
+- Heavy drop shadows, borders AND shadows AND gradients on the same element.
+- Tiny low-contrast grey text; ALL CAPS paragraphs; more than two font families.
+
+## 6. Build, then review like a designer
+
+After building, check honestly and fix before reporting done:
+
+1. Squint test: is the hierarchy obvious — what is first, second, third?
+2. Is the spacing consistent and generous? Any cramped block or misaligned edge?
+3. Does the palette hold together — one accent, tinted neutrals, contrast passes?
+4. Is there one memorable, distinctive element? Would a designer recognise a direction?
+5. Every interactive element has hover and focus states; works at 375px wide.
+6. Nothing from section 5 slipped in.
+
+If a browser or screenshot tool is available, look at the result and iterate. Deliver
+single-file HTML with inline CSS unless the project has its own structure; load fonts from
+Google Fonts with `display=swap` and give a system fallback stack.

package/src/skills.js

@@ -8,6 +8,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+// Skills that ship with Jaitus. A project or personal skill with the same name wins.
+const BUILTIN = path.join(path.dirname(fileURLToPath(import.meta.url)), 'skills', 'builtin');
 
 const MAX_SKILL = 32_000;
 
@@ -47,6 +51,7 @@ export function discoverSkills(cwd) {
     [path.join(cwd, '.claude', 'skills'), 'project'],
     [path.join(os.homedir(), '.jaitus', 'skills'), 'user'],
     [path.join(os.homedir(), '.claude', 'skills'), 'user'],
+    [BUILTIN, 'builtin'],
   ];
   const skills = new Map();
   for (const [root, scope] of roots) {
@@ -58,5 +63,5 @@ export function discoverSkills(cwd) {
 export function skillCatalog(skills) {
   const entries = Object.values(skills || {});
   if (!entries.length) return '';
-  return `\n\nAvailable project workflows (invoke with /<name>):\n${entries.map((s) => `- /${s.name}: ${s.description}`).join('\n')}`;
+  return `\n\nSkills — instructions for particular kinds of work. When the task matches one, call load_skill with its name before you start, and follow it. The user can also run one as /<name>.\n${entries.map((s) => `- ${s.name}: ${s.description}`).join('\n')}`;
 }