atris 3.30.12 → 3.32.0

package/decks/yash-applied-compute-generalist.json

@@ -1,82 +0,0 @@
-{
-  "theme": "ink",
-  "brand": { "name": "The Generalist", "accent": "." },
-  "slides": [
-    {
-      "type": "title",
-      "headline": "Own or **be owned.**",
-      "sub": "Yash Patil, Applied Compute. Custom models on your data. Smaller, cheaper, built for the work you actually do.",
-      "panel": {
-        "header": { "title": "Applied Compute", "meta": "loop" },
-        "rows": [
-          { "title": "Evals", "sub": "your scorecard", "value": "1", "sev": 2 },
-          { "title": "Post-train", "sub": "hill climb RLVR", "value": "2", "sev": 0, "active": true },
-          { "title": "Deploy", "sub": "production at scale", "value": "3", "sev": 1 },
-          { "title": "Improve", "sub": "continuous learning", "value": "4", "sev": 2 }
-        ],
-        "footer": { "left": "open weights in", "right": "your evals stay" }
-      }
-    },
-    {
-      "type": "quote",
-      "text": "Evals are the new **PRD.**",
-      "author": "Yash Patil",
-      "role": "Applied Compute · The Generalist"
-    },
-    {
-      "type": "versus",
-      "heading": "Right model for the right task",
-      "left": {
-        "label": "Frontier model",
-        "items": ["sets the floor", "hardest 20% of spend", "shared capability", "blowtorch scale"]
-      },
-      "right": {
-        "label": "Your model",
-        "items": ["raises the ceiling", "80% of task spend", "private evals", "cost + latency fit"]
-      }
-    },
-    {
-      "type": "timeline",
-      "heading": "How Applied Compute works",
-      "steps": [
-        { "label": "eval", "sub": "define good" },
-        { "label": "data", "sub": "your traces" },
-        { "label": "train", "sub": "RLVR hill climb", "active": true },
-        { "label": "serve", "sub": "production" },
-        { "label": "improve", "sub": "never ends" }
-      ],
-      "sub": "Start from eval. Train on data that looks like the eval. Deploy. Loop forever."
-    },
-    {
-      "type": "receipt",
-      "heading": "DoorDash beat frontier on one task.",
-      "sub": "100k+ merchants per year. Menu photo in. Storefront out.",
-      "receiptTitle": "case study · merchant onboarding",
-      "fields": [
-        { "k": "input", "v": "unstructured menu photos" },
-        { "k": "eval", "v": "what a good storefront looks like" },
-        { "k": "train", "v": "small specialized model + RL" },
-        { "k": "result", "v": "quality above frontier on this task" },
-        { "k": "why", "v": "task-specific beats general at scale" }
-      ],
-      "stamp": "own the intelligence"
-    },
-    {
-      "type": "metricgrid",
-      "heading": "The squeeze",
-      "metrics": [
-        { "value": "$1.3B", "label": "Applied Compute valuation, year one" },
-        { "value": "100k+", "label": "merchants onboarded at DoorDash yearly" },
-        { "value": "80/20", "label": "custom vs frontier spend split Yash cites" },
-        { "value": "Decades", "label": "AI diffusion into the real economy" }
-      ]
-    },
-    {
-      "type": "hero",
-      "headline": "Train on your evals. **Keep your moat.**",
-      "sub": "DoorDash, Cognition, Mercor. Ex-OpenAI post-training. Open weights in, private scorecards stay home.",
-      "mono": "youtube.com/watch?v=B-MxM-OqON8",
-      "footer": "generalist.com · appliedcompute.com · 2026"
-    }
-  ]
-}

package/decks/yash-applied-compute-narrative.json

@@ -1,54 +0,0 @@
-{
-  "theme": "ink",
-  "brand": { "name": "The Generalist", "accent": "." },
-  "slides": [
-    {
-      "type": "interstitial",
-      "kicker": "Applied Compute · The Generalist · 68 min",
-      "text": "Own or **be owned.**"
-    },
-    {
-      "type": "lede",
-      "headline": "Frontier models are a **blowtorch.** Most jobs need a knife.",
-      "dek": "Yash Patil left OpenAI to help companies train custom models on private evals. DoorDash, Cognition, Mercor.",
-      "byline": "Episode · Own or Be Owned"
-    },
-    {
-      "type": "statement",
-      "text": "Evals are the new **PRD.**",
-      "sub": "Every company codifies what good looks like. Those scorecards stay private. They will never ship them to frontier providers."
-    },
-    {
-      "type": "prose",
-      "heading": "If evals are yours, post-training should be yours too.",
-      "paragraphs": [
-        "Open weights in. Your hill to climb. RLVR on traces that look like the eval, not the internet.",
-        "Goldman will not send its production scorecard to a shared frontier API. Neither will DoorDash, Cognition, or Mercor."
-      ]
-    },
-    {
-      "type": "bignumber",
-      "number": "$1.3B",
-      "label": "Applied Compute valuation, year one",
-      "sub": "Mercor as customer. Ex-OpenAI post-training team."
-    },
-    {
-      "type": "split",
-      "heading": "DoorDash beat frontier on one task.",
-      "body": "100k+ merchants onboarded per year. Menu photo in, storefront out. A small specialized model trained on what a good storefront looks like, not general intelligence.",
-      "accent": "100k+",
-      "accentSub": "merchants per year · one narrow task · owned intelligence"
-    },
-    {
-      "type": "statement",
-      "text": "80% of spend on custom models. **20% on frontier.**",
-      "sub": "Frontier sets the floor. Your model raises the ceiling. AI diffusion into the real economy takes decades, not quarters."
-    },
-    {
-      "type": "interstitial",
-      "text": "Train on your evals. **Keep your moat.**",
-      "sub": "youtube.com/watch?v=B-MxM-OqON8 · generalist.com · appliedcompute.com",
-      "align": "START"
-    }
-  ]
-}

package/lib/ax-chat-input.js

@@ -1,164 +0,0 @@
-const MULTILINE_CSI = [
-  '\x1b[13;2~',
-  '\x1b[27;2;13~',
-  '\x1b[23~',
-  '\x1b[13;2u',
-];
-
-const MULTILINE_CSI_RE = /\x1b\[(?:13;2~|27;2;13~|23~|13;2u)/;
-const MULTILINE_CSI_VISIBLE_RE = /\[(?:13;2~|27;2;13~|23~|13;2u)/g;
-
-// Node's readline cannot emit a 'line' whose buffer contains a literal "\n"
-// (it reorders the text around the newline on submit). So newlines live in the
-// buffer as this sentinel while typing is rendered, then are restored to "\n"
-// when the answer is read back via stripMultilineCsiText.
-const MULTILINE_PLACEHOLDER = '\x1f';
-const MULTILINE_PLACEHOLDER_RE = /\x1f/g;
-
-function isMultilineCsiPrefix(buffer) {
-  const value = String(buffer || '');
-  if (!value) return false;
-  return MULTILINE_CSI.some((seq) => seq.startsWith(value));
-}
-
-function isMultilineCsiComplete(buffer) {
-  return MULTILINE_CSI.includes(String(buffer || ''));
-}
-
-function isMultilineCsiKey(key) {
-  const sequence = String(key?.sequence || '');
-  return MULTILINE_CSI_RE.test(sequence);
-}
-
-function isMultilineInsertKey(str, key) {
-  if (!key) return str === '\n';
-  if (key.shift && (key.name === 'return' || key.name === 'enter')) return true;
-  if (key.meta && (key.name === 'return' || key.name === 'enter')) return true;
-  if (str === '\n' && key.name !== 'return') return true;
-  return false;
-}
-
-function isSubmitKey(str, key) {
-  if (key && (key.name === 'return' || key.name === 'enter') && !key.shift && !key.meta) return true;
-  if (!key && str === '\r') return true;
-  return false;
-}
-
-function stripMultilineCsiText(text) {
-  return String(text || '')
-    .replace(MULTILINE_PLACEHOLDER_RE, '\n')
-    .replace(/\x1b\[20[01]~/g, '')
-    .replace(/\x1b\[(?:13;2~|27;2;13~|23~|13;2u)/g, '\n')
-    .replace(MULTILINE_CSI_VISIBLE_RE, '\n')
-    .replace(/\^?\[\[27;2;13~/g, '\n');
-}
-
-// The raw bytes a keypress represents. readline's keypress decoder mangles
-// some CSI sequences (e.g. it splits \x1b[27;2;13~ into a malformed escape
-// whose `sequence` is \x1b[27;2; followed by literal "1", "3", "~"), so when
-// `str` is empty we fall back to the decoded `sequence`.
-function keyBytes(str, key) {
-  if (typeof str === 'string' && str.length > 0) return str;
-  if (key && typeof key.sequence === 'string' && key.sequence.length > 0) return key.sequence;
-  return typeof str === 'string' ? str : '';
-}
-
-function defaultInsertBreak(rl) {
-  if (!rl) return;
-  // _insertString splices a literal newline at the cursor; rl.write('\n')
-  // would instead SUBMIT the line, so it must not be used here.
-  if (typeof rl._insertString === 'function') {
-    rl._insertString('\n');
-    return;
-  }
-  if (typeof rl.line === 'string') {
-    const cursor = Number.isFinite(rl.cursor) ? rl.cursor : rl.line.length;
-    rl.line = rl.line.slice(0, cursor) + '\n' + rl.line.slice(cursor);
-    rl.cursor = cursor + 1;
-    if (typeof rl._refreshLine === 'function') rl._refreshLine();
-    return;
-  }
-  if (typeof rl.write === 'function') rl.write('\n');
-}
-
-function attachMultilineChatInput(rl, { insertBreak = defaultInsertBreak, onSubmit } = {}) {
-  if (!rl || typeof rl._ttyWrite !== 'function') return () => {};
-  const ttyWrite = rl._ttyWrite.bind(rl);
-  let escBuffer = null;
-
-  rl._ttyWrite = (str, key) => {
-    const bytes = keyBytes(str, key);
-
-    // Mid-sequence: keypress decoder shredded a multiline CSI across calls and
-    // we're reassembling it (e.g. \x1b[27;2; then "1", "3", "~").
-    if (escBuffer !== null) {
-      escBuffer += bytes;
-      if (isMultilineCsiComplete(escBuffer)) {
-        escBuffer = null;
-        insertBreak(rl);
-        return;
-      }
-      if (isMultilineCsiPrefix(escBuffer) && escBuffer.length <= 24) {
-        return;
-      }
-      // Diverged from every target sequence: replay the swallowed bytes
-      // literally (current keypress is already included in the buffer).
-      const replay = escBuffer;
-      escBuffer = null;
-      for (const ch of replay) ttyWrite(ch);
-      return;
-    }
-
-    // Whole multiline CSI delivered in a single keypress (terminals or Node
-    // versions that don't shred it).
-    if (isMultilineCsiKey(key) || MULTILINE_CSI_RE.test(bytes)) {
-      insertBreak(rl);
-      return;
-    }
-
-    // Start of a shredded multiline CSI: begin buffering from the raw escape.
-    if (bytes && bytes.charCodeAt(0) === 0x1b && isMultilineCsiPrefix(bytes)) {
-      escBuffer = bytes;
-      if (isMultilineCsiComplete(escBuffer)) {
-        escBuffer = null;
-        insertBreak(rl);
-      }
-      return;
-    }
-
-    // Plain Shift+Enter / Meta+Enter / synthetic \n.
-    if (isMultilineInsertKey(str, key)) {
-      insertBreak(rl);
-      return;
-    }
-
-    // Submit (Enter): the line buffer keeps its literal "\n" so readline's own
-    // multiline cursor math advances past every wrapped row (otherwise the box
-    // bottom border overwrites a row). readline mangles the emitted 'line'
-    // string when it holds a newline, so we hand the true buffer to onSubmit
-    // and the caller reads that instead of the line event.
-    if (isSubmitKey(str, key) && typeof rl.line === 'string' && rl.line.includes('\n')) {
-      if (typeof onSubmit === 'function') onSubmit(rl.line);
-    }
-
-    ttyWrite(str, key);
-  };
-
-  return () => {
-    rl._ttyWrite = ttyWrite;
-    escBuffer = null;
-  };
-}
-
-module.exports = {
-  MULTILINE_CSI,
-  MULTILINE_PLACEHOLDER,
-  attachMultilineChatInput,
-  isMultilineCsiComplete,
-  isMultilineCsiKey,
-  isMultilineInsertKey,
-  isMultilineCsiPrefix,
-  isSubmitKey,
-  stripMultilineCsiText,
-  keyBytes,
-};

package/lib/ax-goal.js

@@ -1,307 +0,0 @@
-const GOAL_CLEAR_ALIASES = new Set(['clear', 'stop', 'off', 'reset', 'none', 'cancel']);
-const GOAL_ACHIEVED_RE = /^\s*GOAL_ACHIEVED:\s*(.+)$/im;
-const GOAL_JSON_RE = /\{[\s\S]*"achieved"\s*:\s*(true|false)[\s\S]*\}/i;
-
-function parseTokenBudget(raw) {
-  const text = String(raw || '').trim().toUpperCase();
-  const match = text.match(/^(\d+(?:\.\d+)?)([KMB])?$/);
-  if (!match) return null;
-  let value = Number(match[1]);
-  if (match[2] === 'K') value *= 1000;
-  if (match[2] === 'M') value *= 1000000;
-  if (match[2] === 'B') value *= 1000000000;
-  return Math.round(value);
-}
-
-function parseGoalCommand(line) {
-  const raw = String(line || '').trim();
-  const lower = raw.toLowerCase();
-  if (!lower.startsWith('/goal')) return null;
-
-  const rest = raw.slice(5).trim();
-  if (!rest) return { action: 'status' };
-
-  const firstWord = rest.split(/\s+/)[0].toLowerCase();
-  if (GOAL_CLEAR_ALIASES.has(firstWord)) return { action: 'clear' };
-
-  let condition = rest;
-  let tokenBudget = null;
-  const tokensMatch = condition.match(/^--tokens\s+(\S+)\s+([\s\S]+)$/i);
-  if (tokensMatch) {
-    tokenBudget = parseTokenBudget(tokensMatch[1]);
-    condition = tokensMatch[2].trim();
-  }
-
-  const maxTurnsMatch = condition.match(/\b(?:max|stop after|within)\s+(\d+)\s+turns?\b/i);
-  const maxTurns = maxTurnsMatch ? Number(maxTurnsMatch[1]) : null;
-
-  if (!condition) return { action: 'status' };
-  return { action: 'set', condition, maxTurns, tokenBudget };
-}
-
-function createGoalState(condition, options = {}) {
-  return {
-    active: true,
-    condition: String(condition || '').trim(),
-    maxTurns: Number.isFinite(options.maxTurns) ? options.maxTurns : null,
-    tokenBudget: Number.isFinite(options.tokenBudget) ? options.tokenBudget : null,
-    turns: 0,
-    evalTurns: 0,
-    tokensUsed: 0,
-    creditsUsed: 0,
-    startedAt: Date.now(),
-    lastReason: 'Goal started — working toward the condition.',
-    achieved: false,
-    achievedAt: null,
-  };
-}
-
-function goalElapsedMs(goal) {
-  const end = goal.achievedAt || Date.now();
-  return Math.max(0, end - (goal.startedAt || end));
-}
-
-function truncateGoalText(text, limit = 72) {
-  const value = String(text || '').trim();
-  if (value.length <= limit) return value;
-  return `${value.slice(0, limit - 1)}…`;
-}
-
-function compactGoalHistory(history = [], limit = 8) {
-  return history
-    .slice(-limit)
-    .map(turn => `${turn.role}: ${String(turn.content || '').slice(0, 900)}`)
-    .join('\n');
-}
-
-function buildGoalDirective(goal, options = {}) {
-  const condition = goal.condition;
-  const reason = goal.lastReason && goal.turns > 0
-    ? `\nEvaluator guidance from last turn: ${goal.lastReason}`
-    : '';
-  return [
-    'Work autonomously toward this completion condition:',
-    condition,
-    '',
-    'Use local tools as needed. Do not ask the user for permission between steps.',
-    'Do not declare the goal achieved yourself — a separate evaluator decides that.',
-    reason,
-    options.continue ? '\nContinue from the recent conversation below.' : '',
-  ].filter(Boolean).join('\n');
-}
-
-function buildGoalEvalPrompt(goal, history, lastOutput) {
-  return [
-    'You are a strict goal evaluator for a coding agent session.',
-    'Reply with JSON only: {"achieved": true|false, "reason": "short reason"}',
-    'Judge only from observable evidence in the transcript and latest output.',
-    'If the condition requires command output or file contents, require proof in the transcript.',
-    '',
-    `Goal condition: ${goal.condition}`,
-    '',
-    'Recent conversation:',
-    compactGoalHistory(history),
-    '',
-    'Latest assistant output:',
-    String(lastOutput || '').slice(0, 4000),
-  ].join('\n');
-}
-
-function parseGoalEvalResponse(text) {
-  const raw = String(text || '').trim();
-  if (!raw) return null;
-
-  const marker = raw.match(GOAL_ACHIEVED_RE);
-  if (marker) {
-    return { achieved: true, reason: marker[1].trim() };
-  }
-
-  const jsonMatch = raw.match(GOAL_JSON_RE);
-  if (!jsonMatch) return null;
-  try {
-    const parsed = JSON.parse(jsonMatch[0]);
-    return {
-      achieved: parsed.achieved === true,
-      reason: String(parsed.reason || '').trim() || (parsed.achieved ? 'Condition met.' : 'Condition not met yet.'),
-    };
-  } catch {
-    return null;
-  }
-}
-
-function parseGoalAchievedMarker(text) {
-  const marker = String(text || '').match(GOAL_ACHIEVED_RE);
-  if (!marker) return null;
-  return { achieved: true, reason: marker[1].trim() };
-}
-
-function accumulateGoalUsage(goal, result, creditsFromState) {
-  if (!goal || !result) return;
-  const credits = typeof creditsFromState === 'function' ? creditsFromState(result) : null;
-  if (Number.isFinite(credits) && credits > 0) {
-    goal.creditsUsed += credits;
-  }
-  const approxTokens = Math.max(0, Math.round(String(result.output || '').length / 4));
-  goal.tokensUsed += approxTokens;
-}
-
-function goalBudgetExceeded(goal) {
-  if (!goal || !Number.isFinite(goal.tokenBudget)) return false;
-  return goal.tokensUsed >= goal.tokenBudget;
-}
-
-function goalTurnLimitReached(goal) {
-  if (!goal || !Number.isFinite(goal.maxTurns)) return false;
-  return goal.turns >= goal.maxTurns;
-}
-
-function clearGoalState(goal) {
-  if (!goal) return null;
-  goal.active = false;
-  return goal;
-}
-
-function finishGoalAchieved(goal, reason) {
-  goal.active = false;
-  goal.achieved = true;
-  goal.achievedAt = Date.now();
-  goal.lastReason = reason || 'Condition met.';
-  return goal;
-}
-
-function formatGoalCounter(goal) {
-  const turns = `${goal.turns}${Number.isFinite(goal.maxTurns) ? `/${goal.maxTurns}` : ''}`;
-  const duration = `${Math.max(1, Math.round(goalElapsedMs(goal) / 1000))}s`;
-  const usage = [];
-  if (goal.creditsUsed > 0) usage.push(`${goal.creditsUsed} credits`);
-  if (goal.tokensUsed > 0) usage.push(`~${goal.tokensUsed} tokens`);
-  return { turns, duration, usage: usage.join(' · ') };
-}
-
-function formatGoalStatus(goal, options = {}) {
-  const paint = options.paint || ((text) => String(text));
-  if (!goal) {
-    return 'No active goal. Set one with /goal <condition>.';
-  }
-
-  const counter = formatGoalCounter(goal);
-  const lines = [];
-
-  if (goal.active) {
-    lines.push(paint('◎ /goal active', [options.bold, options.magenta]));
-    lines.push(paint(goal.condition, [options.bold]));
-    lines.push(paint(`turn ${counter.turns} · ${counter.duration}${counter.usage ? ` · ${counter.usage}` : ''}`, [options.muted]));
-    if (goal.lastReason) lines.push(paint(`reason: ${goal.lastReason}`, [options.muted]));
-    if (Number.isFinite(goal.tokenBudget)) {
-      lines.push(paint(`budget: ~${goal.tokensUsed}/${goal.tokenBudget} tokens`, [options.muted]));
-    }
-    return lines.join('\n');
-  }
-
-  if (goal.achieved) {
-    lines.push(paint('✦ /goal achieved', [options.bold, options.ok || options.magenta]));
-    lines.push(paint(goal.condition, [options.bold]));
-    lines.push(paint(`${counter.turns} turns · ${counter.duration}${counter.usage ? ` · ${counter.usage}` : ''}`, [options.muted]));
-    if (goal.lastReason) lines.push(paint(`reason: ${goal.lastReason}`, [options.muted]));
-    return lines.join('\n');
-  }
-
-  lines.push(paint('Goal stopped.', [options.muted]));
-  lines.push(paint(goal.condition, [options.bold]));
-  lines.push(paint(`turn ${counter.turns} · ${counter.duration}`, [options.muted]));
-  if (goal.lastReason) lines.push(paint(`reason: ${goal.lastReason}`, [options.muted]));
-  return lines.join('\n');
-}
-
-function formatGoalActiveBanner(goal, options = {}) {
-  if (!goal || !goal.active) return '';
-  const paint = options.paint || ((text) => String(text));
-  const counter = formatGoalCounter(goal);
-  return paint(
-    `◎ /goal active · ${truncateGoalText(goal.condition, 56)} · turn ${counter.turns}${Number.isFinite(goal.maxTurns) ? `/${goal.maxTurns}` : ''} · ${counter.duration}`,
-    [options.bold, options.magenta]
-  );
-}
-
-function formatGoalAchieved(goal, options = {}) {
-  const paint = options.paint || ((text) => String(text));
-  const counter = formatGoalCounter(goal);
-  return [
-    paint('✦ Goal achieved', [options.bold, options.magenta]),
-    paint(goal.condition, [options.bold, options.accent]),
-    paint(`${counter.turns} turns · ${counter.duration}${counter.usage ? ` · ${counter.usage}` : ''}`, [options.muted]),
-    goal.lastReason ? paint(`reason: ${goal.lastReason}`, [options.muted]) : '',
-  ].filter(Boolean).join('\n');
-}
-
-function formatGoalContinue(goal, options = {}) {
-  const paint = options.paint || ((text) => String(text));
-  return paint(`◎ continuing goal · turn ${goal.turns + 1}${Number.isFinite(goal.maxTurns) ? `/${goal.maxTurns}` : ''} · ${goal.lastReason}`, [options.magenta]);
-}
-
-function formatGoalStopped(goal, reason, options = {}) {
-  const paint = options.paint || ((text) => String(text));
-  const counter = formatGoalCounter(goal);
-  return [
-    paint('◎ Goal stopped', [options.bold, options.muted]),
-    paint(reason, [options.muted]),
-    paint(`${counter.turns} turns · ${counter.duration}`, [options.muted]),
-  ].join('\n');
-}
-
-async function evaluateGoalTurn(goal, ctx = {}, deps = {}) {
-  const marker = parseGoalAchievedMarker(ctx.lastOutput);
-  if (marker) return marker;
-
-  if (typeof deps.evaluateGoal === 'function') {
-    return deps.evaluateGoal(goal, ctx);
-  }
-
-  if (typeof deps.postTurn !== 'function') {
-    return { achieved: false, reason: goal.lastReason || 'Condition not met yet.' };
-  }
-
-  const evalOutput = { isTTY: false, write() {} };
-  try {
-    const result = await deps.postTurn(buildGoalEvalPrompt(goal, ctx.history || [], ctx.lastOutput), {
-      ...(ctx.turnOptions || {}),
-      mode: 'fast',
-      history: [],
-      output: evalOutput,
-      showProgress: false,
-      goalEval: true,
-    });
-    const parsed = parseGoalEvalResponse(result.output);
-    if (parsed) return parsed;
-  } catch (error) {
-    return { achieved: false, reason: `Evaluator unavailable: ${error.message}` };
-  }
-
-  return { achieved: false, reason: goal.lastReason || 'Condition not met yet.' };
-}
-
-module.exports = {
-  GOAL_CLEAR_ALIASES,
-  accumulateGoalUsage,
-  buildGoalDirective,
-  buildGoalEvalPrompt,
-  clearGoalState,
-  compactGoalHistory,
-  createGoalState,
-  evaluateGoalTurn,
-  finishGoalAchieved,
-  formatGoalAchieved,
-  formatGoalActiveBanner,
-  formatGoalContinue,
-  formatGoalCounter,
-  formatGoalStatus,
-  formatGoalStopped,
-  goalBudgetExceeded,
-  goalElapsedMs,
-  goalTurnLimitReached,
-  parseGoalAchievedMarker,
-  parseGoalCommand,
-  parseGoalEvalResponse,
-  parseTokenBudget,
-  truncateGoalText,
-};

package/lib/ax-prefs.js

@@ -1,63 +0,0 @@
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const MEMBER_SLUG = 'ax';
-const PREFS_PATH = path.join(os.homedir(), '.atris', 'ax.json');
-const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
-
-function truthy(value) {
-  return TRUTHY.has(String(value || '').trim().toLowerCase());
-}
-
-function loadAxPrefs() {
-  try {
-    if (!fs.existsSync(PREFS_PATH)) {
-      return { member_slug: MEMBER_SLUG, bypass_permissions: false };
-    }
-    const parsed = JSON.parse(fs.readFileSync(PREFS_PATH, 'utf8'));
-    return {
-      member_slug: MEMBER_SLUG,
-      bypass_permissions: parsed.bypass_permissions === true,
-    };
-  } catch {
-    return { member_slug: MEMBER_SLUG, bypass_permissions: false };
-  }
-}
-
-function saveAxPrefs(prefs) {
-  fs.mkdirSync(path.dirname(PREFS_PATH), { recursive: true });
-  fs.writeFileSync(PREFS_PATH, `${JSON.stringify({
-    member_slug: MEMBER_SLUG,
-    bypass_permissions: prefs.bypass_permissions === true,
-    updated_at: new Date().toISOString(),
-  }, null, 2)}\n`);
-  return loadAxPrefs();
-}
-
-function setBypassPermissions(enabled, { persist = true } = {}) {
-  const next = { member_slug: MEMBER_SLUG, bypass_permissions: enabled === true };
-  return persist ? saveAxPrefs(next) : next;
-}
-
-function resolveBypassPermissions(options = {}) {
-  if (options.bypassPermissions === true) return true;
-  if (options.bypassPermissions === false) return false;
-  if (truthy(process.env.AX_BYPASS_PERMISSIONS)) return true;
-  if (truthy(process.env.AX_SAFE_PERMISSIONS)) return false;
-  return loadAxPrefs().bypass_permissions === true;
-}
-
-function permissionsLabel(options = {}) {
-  return resolveBypassPermissions(options) ? 'bypass' : 'safe';
-}
-
-module.exports = {
-  MEMBER_SLUG,
-  PREFS_PATH,
-  loadAxPrefs,
-  saveAxPrefs,
-  setBypassPermissions,
-  resolveBypassPermissions,
-  permissionsLabel,
-};