atris 3.82.15 → 3.82.17

package/lib/campaign-new.js

@@ -9,6 +9,7 @@
 const fs = require('fs');
 const path = require('path');
 const { newCampaignId } = require('./campaign-store');
+const { engineCannotRun, explainStall } = require('./campaign-engine-stall');
 
 const DEFAULT_BUDGET = 20;
 const DEFAULT_OWNER = 'mission-lead';
@@ -100,10 +101,11 @@ function parseDraft(text, members) {
 async function askOwner(root, view, prompt) {
   const { resolveEngineForMember } = require('./member-engine');
   const { runEngineAskJobs } = require('./engine-ask');
+  const { askSummary } = require('./campaign-engine-stall');
   const pick = resolveEngineForMember(view.owner, root) || {};
   const engine = (pick.engine && pick.engine.id) || 'claude';
   const [answer] = await runEngineAskJobs([{ engine, model: pick.model || '', prompt, label: 'campaign new judge' }], { root, timeoutMs: ASK_TIMEOUT_MS });
-  return { text: (answer && answer.stdout) || '', engine, ok: Boolean(answer && answer.ok) };
+  return askSummary(answer, engine, { no_engine: !(pick.engine && pick.engine.id) });
 }
 
 function writeJudge(root, id, script) {
@@ -135,7 +137,9 @@ async function draftJudge({ root, goal, owner, idFlag, timeout, ask, judge }) {
     const draft = parseDraft(answer.text, members);
     if (!draft) {
       previous = 'the reply was not one JSON object with a judge_script';
-      last = { error: `${owner}'s engine (${answer.engine || 'unknown'}) did not return a judge script` };
+      last = { error: `${owner}'s engine (${answer.engine || 'unknown'}) did not return a judge script`, answer };
+      // Asking again cannot help an engine that never ran.
+      if (engineCannotRun(answer)) break;
       continue;
     }
     if (!draft.title) draft.title = goal.slice(0, 80);
@@ -218,11 +222,18 @@ async function draftAndStart(args, ctx, deps = {}) {
     judge: ctx.judge,
   });
   if (!result.ok) {
+    const byHand = `write the judge yourself: atris campaign start ${shellQuote(goal.slice(0, 80))} --judge "<command that fails today>" --budget ${budget}`;
+    // No draft came back: name the engine and why, then the one next step.
+    const stall = result.answer
+      ? explainStall({ owner, answer: result.answer, wanted: 'a judge script', byHand, again: 'atris campaign new' })
+      : null;
+    const error = stall ? stall.why : result.error;
+    const next = stall ? stall.next : byHand;
     if (ctx.asJson) {
-      console.log(JSON.stringify({ ok: false, error: result.error, draft: result.draft || null, reading: result.reading || null }));
+      console.log(JSON.stringify({ ok: false, error, next, engine: stall ? stall.engine : result.engine || null, cause: stall ? stall.kind : null, draft: result.draft || null, reading: result.reading || null }));
       return 1;
     }
-    return ctx.fail(`${result.error}. Write the judge yourself: atris campaign start "<title>" --judge "<command that fails today>" --budget ${budget}`, 1);
+    return ctx.fail(`${error}.\nnext: ${next}`, 1);
   }
 
   const draft = { id: result.id, title: result.draft.title, judge: result.command, judge_file: result.judgeFile, why: result.draft.why, seats: result.draft.seats, owner, budget, engine: result.engine };

package/lib/design-api.js

@@ -34,14 +34,25 @@ function readKeyFile(file = DESIGN_KEY_FILE) {
 }
 
 // Returns the bearer token for design calls, or null when nothing is set up.
+// A developer key (env, then the saved key file) comes before the login token:
+// the design server only accepts developer keys, so a saved key must never be
+// shadowed by being signed in.
 function resolveDesignKey(env = process.env, deps = {}) {
   const fromEnv = env.ATRIS_API_KEY && env.ATRIS_API_KEY.trim();
   if (fromEnv) return fromEnv;
+  const fromFile = (deps.readKeyFile || readKeyFile)();
+  if (fromFile) return fromFile;
   const load = deps.loadCredentials || loadCredentials;
   const creds = load();
   const token = creds && typeof creds.token === 'string' ? creds.token.trim() : '';
-  if (token) return token;
-  return (deps.readKeyFile || readKeyFile)();
+  return token || null;
+}
+
+// A design call that was refused for a sign-in token gets a next step.
+const DESIGN_NEEDS_KEY = 'design tools take a developer key, not your sign-in. make one with atris api-key create, then set ATRIS_API_KEY or save it to ~/.atris/design-api-key';
+
+function isDeveloperKey(key) {
+  return /^atris_/.test(String(key || '').trim());
 }
 
 // One JSON call against the design API. Returns { ok, status, data, error }.
@@ -68,9 +79,10 @@ async function designRequest(pathname, options = {}) {
   let data = null;
   try { data = text ? JSON.parse(text) : null; } catch { data = null; }
   const ok = res.status >= 200 && res.status < 300;
-  const error = !ok
+  let error = !ok
     ? (data && typeof data === 'object' && (data.detail || data.error || data.message)) || text.slice(0, 200) || `http ${res.status}`
     : undefined;
+  if (res.status === 401 && !isDeveloperKey(key)) error = `${typeof error === 'string' ? error : 'unauthorized'}. ${DESIGN_NEEDS_KEY}`;
   return { ok, status: res.status, data, error };
 }
 

package/lib/ninety-nine-sync.js

@@ -3,7 +3,7 @@
 const { createHash } = require('node:crypto');
 const { apiRequestJson, getApiBaseUrl } = require('../utils/api');
 const { decodeJwtClaims } = require('../utils/auth');
-const { parseSessionLog, lineIdentity, uniqueLines } = require('./ninety-nine');
+const { parseSessionLog, lineIdentity, uniqueLines, localBlocks, localDate, blocksLine, openDays } = require('./ninety-nine');
 
 const WORKSPACE_DIRECTORY = 'atris/99';
 
@@ -153,4 +153,74 @@ async function syncLines({ records, sync, checkpoint = {}, deviceId, credentials
   };
 }
 
-module.exports = { validateSync, checkpointKey, syncLines };
+// The account the day endpoint saves to, whatever the session sync target is.
+function blockAccountKey(credentials) {
+  const account = credentials.user_id || decodeJwtClaims(credentials.token)?.sub || credentials.email
+    || createHash('sha256').update(credentials.token).digest('hex');
+  return createHash('sha256').update(JSON.stringify([getApiBaseUrl(), account, 'blocks'])).digest('hex');
+}
+
+function blockPrint(block) {
+  return createHash('sha256').update(JSON.stringify(block)).digest('hex').slice(0, 16);
+}
+
+const BLOCKS_PER_SAVE = 24;
+const SENT_KEEP_DAYS = 7;
+
+// Each finished focus block made here goes once to PUT /api/99/day/{day} under
+// habits.deep_work.blocks, with done, as the phone and web send it. `sent` maps
+// block id to "day|print" of the copy the server took. A save the server refuses
+// for good (400, or 429 for a full day) settles its blocks so one bad block never holds the rest.
+async function syncBlocks({ records, sent = {}, credentials, now = new Date(), dryRun = false, request = apiRequestJson }) {
+  const open = new Set(openDays(now));
+  const pending = localBlocks(records).filter(({ day, block }) => open.has(day)
+    && sent[block.id] !== `${day}|${blockPrint(block)}`);
+  const next = { ...sent };
+  const result = { send: pending.map((item) => item.block), sent: next, line: null, refused: null, locked: false };
+  if (dryRun || !pending.length) return result;
+  const byDay = new Map();
+  for (const item of pending) {
+    if (!byDay.has(item.day)) byDay.set(item.day, []);
+    byDay.get(item.day).push(item);
+  }
+  for (const [day, items] of byDay) {
+    for (let offset = 0; offset < items.length; offset += BLOCKS_PER_SAVE) {
+      const batch = items.slice(offset, offset + BLOCKS_PER_SAVE);
+      const query = new URLSearchParams({ tz_offset_minutes: String(batch[0].tz_offset_minutes) });
+      let response;
+      try {
+        response = await request(`/99/day/${day}?${query}`, {
+          method: 'PUT', token: credentials.token,
+          body: { habits: { deep_work: { done: true, blocks: batch.map((item) => item.block) } } },
+        });
+      } catch {
+        throw new Error('could not reach the 99 server; try again');
+      }
+      if (response?.status === 402) {
+        result.locked = true;
+        return result;
+      }
+      if ([401, 403].includes(response?.status)) throw new Error('sync needs your signed-in user login; run atris login');
+      if ([400, 429].includes(response?.status)) {
+        result.refused = String(response?.data?.detail?.error || 'refused').slice(0, 40);
+      } else if (!response?.ok) {
+        throw new Error(`the 99 server did not take the focus blocks${response?.status ? ` (http ${response.status})` : ''}; try again`);
+      } else {
+        const deep = response.data?.habits?.deep_work;
+        if (Number.isInteger(deep?.block_count) && Number.isInteger(deep?.block_minutes)) {
+          result.line = blocksLine({ count: deep.block_count, minutes: deep.block_minutes });
+        }
+      }
+      for (const item of batch) next[item.block.id] = `${item.day}|${blockPrint(item.block)}`;
+    }
+  }
+  const oldest = new Date(now);
+  oldest.setDate(oldest.getDate() - SENT_KEEP_DAYS);
+  const cutoff = localDate(oldest);
+  for (const [id, value] of Object.entries(next)) {
+    if (typeof value !== 'string' || value.slice(0, 10) < cutoff) delete next[id];
+  }
+  return result;
+}
+
+module.exports = { validateSync, checkpointKey, syncLines, syncBlocks, blockAccountKey };

package/lib/ninety-nine.js

@@ -4,6 +4,10 @@ const LENGTHS = { focus: [25, 50, 90], meditate: [10, 20, 30] };
 const SOURCES = ['cli', 'mac', 'ios'];
 const PAUSE_LIMIT_MS = 30 * 60000;
 const HEALTH_FIELDS = ['sleep_min', 'steps', 'workout_min', 'mindful_min'];
+const OUTCOMES = ['yes', 'partly', 'no'];
+const INTENTION_MAX = 200;
+const BLOCK_NOTE_MAX = 500;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
 function lineIdentity(record) {
   return `${record.type}|${record.type === 'health_day' ? record.date : record.id}|${record.at}|${record.source}`;
@@ -19,6 +23,14 @@ function uniqueLines(records) {
   });
 }
 
+function oneLineText(value) {
+  return typeof value === 'string' && !/[\r\n\u2028\u2029]/.test(value);
+}
+
+function oneLine(value, limit) {
+  return String(value ?? '').replace(/\s+/g, ' ').trim().slice(0, limit).trim();
+}
+
 function validLength(kind, minutes) {
   return Object.hasOwn(LENGTHS, kind) && LENGTHS[kind].includes(minutes);
 }
@@ -31,10 +43,12 @@ function parseSessionLog(text) {
     const common = record && record.v === 1 && SOURCES.includes(record.source)
       && typeof record.at === 'string' && Number.isFinite(Date.parse(record.at));
     const session = typeof record?.id === 'string' && record.id;
-    const start = record?.type === 'start' && validLength(record.kind, record.planned_min);
+    const start = record?.type === 'start' && validLength(record.kind, record.planned_min)
+      && (record.intention === undefined || oneLineText(record.intention));
     const end = record?.type === 'end' && ['done', 'partial'].includes(record.status)
       && (record.inferred === undefined || typeof record.inferred === 'boolean')
-      && (record.note === undefined || (typeof record.note === 'string' && !/[\r\n\u2028\u2029]/.test(record.note)));
+      && (record.note === undefined || oneLineText(record.note))
+      && (record.outcome === undefined || record.outcome === null || OUTCOMES.includes(record.outcome));
     const pause = ['pause', 'resume'].includes(record?.type);
     const health = record?.type === 'health_day' && typeof record.date === 'string'
       && /^\d{4}-\d{2}-\d{2}$/.test(record.date)
@@ -54,6 +68,7 @@ function foldSessions(records) {
   const sessions = new Map();
   const events = new Map();
   const ends = new Map();
+  const outcomes = new Map();
   // Stable sort preserves append order when timestamps tie, without rewriting the log.
   for (const record of uniqueLines(records).sort((a, b) => Date.parse(a.at) - Date.parse(b.at))) {
     if (record.type === 'health_day') continue;
@@ -68,6 +83,7 @@ function foldSessions(records) {
         ended_at: null,
         status: 'running',
       });
+      if (record.intention) sessions.get(record.id).intention = record.intention;
       events.set(record.id, []);
     } else {
       const session = sessions.get(record.id);
@@ -76,6 +92,11 @@ function foldSessions(records) {
         events.get(record.id).push(record);
         continue;
       }
+      // How the block went counts from any end record: the newest answer wins, and
+      // null (asked, skipped) only stands when there is no answer at all.
+      if (record.outcome !== undefined && (record.outcome !== null || !outcomes.has(record.id))) {
+        outcomes.set(record.id, record.outcome);
+      }
       const previous = ends.get(record.id);
       // A person's end wins over an automatic observation, in either log order.
       if (!previous || (previous.inferred === true && record.inferred !== true)
@@ -115,6 +136,7 @@ function foldSessions(records) {
       session.status = end.status;
       if (end.note !== undefined) session.note = end.note;
       if (end.inferred === true) session.inferred = true;
+      if (outcomes.has(session.id)) session.outcome = outcomes.get(session.id);
     }
   }
   return [...sessions.values()];
@@ -127,9 +149,50 @@ function runningSession(sessions, now) {
   return running[0] || null;
 }
 
-function startRecord(kind, plannedMin, now, id) {
+function startRecord(kind, plannedMin, now, id, intention = '') {
   if (!validLength(kind, plannedMin)) throw new Error('choose a supported session length');
-  return { v: 1, type: 'start', id, kind, planned_min: plannedMin, at: now.toISOString(), source: 'cli' };
+  const record = { v: 1, type: 'start', id, kind, planned_min: plannedMin, at: now.toISOString(), source: 'cli' };
+  const line = kind === 'focus' ? oneLine(intention, INTENTION_MAX) : '';
+  if (line) record.intention = line;
+  return record;
+}
+
+// How a finished focus block went: yes, partly, no, or null for asked and skipped.
+// Only a focus block that ran its full time carries it.
+function withOutcome(record, session, outcome) {
+  if ((outcome === null || OUTCOMES.includes(outcome)) && session.kind === 'focus' && record.status === 'done') {
+    record.outcome = outcome;
+  }
+  return record;
+}
+
+// One more end line that adds the answer to a block that already ended. It sits after
+// the real end, so every face keeps the earliest end and its time; only the answer is new.
+function answerRecord(session, now, outcome) {
+  const at = Math.max(now.getTime(), Date.parse(session.ended_at) + 1);
+  return {
+    v: 1, type: 'end', id: session.id, status: 'done', at: new Date(at).toISOString(), source: 'cli', inferred: true, outcome,
+  };
+}
+
+// The server takes saves for the local today, and for yesterday until 3 in the morning.
+function openDays(now) {
+  const days = [localDate(now)];
+  if (now.getHours() < 3) {
+    const yesterday = new Date(now);
+    yesterday.setDate(yesterday.getDate() - 1);
+    days.push(localDate(yesterday));
+  }
+  return days;
+}
+
+// Finished focus blocks made on this computer, still open for a save, never asked about.
+function unansweredBlocks(records, now) {
+  const sources = new Map(records.filter((record) => record.type === 'start').map((record) => [record.id, record.source]));
+  const open = new Set(openDays(now));
+  return foldSessions(records).filter((session) => session.kind === 'focus' && session.status === 'done'
+    && session.outcome === undefined && ['cli', 'mac'].includes(sources.get(session.id))
+    && open.has(localDate(new Date(session.started_at))));
 }
 
 function endRecord(session, now, note = '') {
@@ -208,6 +271,72 @@ function sessionsToday(sessions, now) {
   };
 }
 
+// A focus block counts on the local day it started, as on the phone.
+function blocksToday(sessions, now) {
+  const date = localDate(now);
+  const blocks = sessions.filter((session) => session.kind === 'focus' && session.status === 'done'
+    && localDate(new Date(session.started_at)) === date);
+  return { count: blocks.length, minutes: blocks.reduce((sum, session) => sum + session.planned_min, 0) };
+}
+
+// 125 is "2 hours 5 minutes", 60 is "1 hour", 25 is "25 minutes".
+function blockDuration(minutes) {
+  const hours = Math.floor(minutes / 60);
+  const rest = minutes % 60;
+  const hourText = hours === 1 ? '1 hour' : `${hours} hours`;
+  const minuteText = rest === 1 ? '1 minute' : `${rest} minutes`;
+  if (hours === 0) return minuteText;
+  return rest === 0 ? hourText : `${hourText} ${minuteText}`;
+}
+
+// "3 blocks, 2 hours 5 minutes"; null with no finished block.
+function blocksLine({ count, minutes }) {
+  if (!count) return null;
+  return `${count === 1 ? '1 block' : `${count} blocks`}, ${blockDuration(minutes)}`;
+}
+
+function offsetMinutesAt(date) {
+  return -date.getTimezoneOffset();
+}
+
+// ISO 8601 with the local offset at that moment, whole seconds, like the phone writes.
+function isoWithOffset(date) {
+  const offset = offsetMinutesAt(date);
+  const local = new Date(date.getTime() + offset * 60000).toISOString().slice(0, 19);
+  if (offset === 0) return `${local}Z`;
+  const sign = offset < 0 ? '-' : '+';
+  const abs = Math.abs(offset);
+  return `${local}${sign}${String(Math.floor(abs / 60)).padStart(2, '0')}:${String(abs % 60).padStart(2, '0')}`;
+}
+
+// A finished focus block in the shape of "Contract: blocks" in project99's deep-work idea.
+// Only blocks made on this computer go; the phone sends its own.
+function blockFromSession(session) {
+  if (session.kind !== 'focus' || session.status !== 'done' || !UUID.test(session.id)) return null;
+  const started = new Date(session.started_at);
+  return {
+    day: localDate(started),
+    tz_offset_minutes: offsetMinutesAt(started),
+    block: {
+      id: session.id,
+      minutes: session.planned_min,
+      intention: oneLine(session.intention, INTENTION_MAX),
+      started_at: isoWithOffset(started),
+      ended_at: isoWithOffset(new Date(session.ended_at)),
+      outcome: session.outcome ?? null,
+      note: oneLine(session.note, BLOCK_NOTE_MAX),
+    },
+  };
+}
+
+function localBlocks(records) {
+  const sources = new Map(records.filter((record) => record.type === 'start').map((record) => [record.id, record.source]));
+  return foldSessions(records)
+    .filter((session) => ['cli', 'mac'].includes(sources.get(session.id)))
+    .map(blockFromSession)
+    .filter(Boolean);
+}
+
 function healthToday(records, now) {
   const date = localDate(now);
   let latest;
@@ -228,6 +357,21 @@ function healthSummary(record) {
 }
 
 module.exports = {
+  OUTCOMES,
+  INTENTION_MAX,
+  BLOCK_NOTE_MAX,
+  oneLine,
+  localDate,
+  withOutcome,
+  answerRecord,
+  openDays,
+  unansweredBlocks,
+  blocksToday,
+  blockDuration,
+  blocksLine,
+  isoWithOffset,
+  blockFromSession,
+  localBlocks,
   validLength,
   parseSessionLog,
   foldSessions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.82.15",
+  "version": "3.82.17",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof. project memory your coding agents share across sessions.",
   "mcpName": "io.github.atrislabs/atris",
   "main": "bin/atris.js",