aibroker 0.61.3 → 0.61.5

package/dist/daemon/manage.js

@@ -19,7 +19,7 @@
  * carries one-shot instructions from the operator into the next arming, and it
  * says what it did. Everything requiring judgement stays with the person.
  */
-import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, mkdirSync, unlinkSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, mkdirSync, unlinkSync, chmodSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { join, dirname } from "node:path";
 import { homedir } from "node:os";
@@ -1304,27 +1304,50 @@ export function defaultHandoverTarget(cwd, notesDirExists) {
         return null;
     return join(cwd, "Notes", "TODO.md");
 }
+/**
+ * The live transcript's tail. File mtime is not evidence of life: a stale
+ * transcript keeps getting non-message records appended. Among the five most
+ * recently modified files, the live one is the one whose last user/assistant
+ * record is newest; files with no such record in the tail rank last.
+ * Only the tail is read — these files reach tens of megabytes.
+ */
+export function liveTranscriptTail(dir) {
+    let best = null;
+    const files = readdirSync(dir)
+        .filter((f) => f.endsWith(".jsonl"))
+        .map((f) => ({ f, m: statSync(join(dir, f)).mtimeMs }))
+        .sort((a, b) => b.m - a.m)
+        .slice(0, 5);
+    for (const { f } of files) {
+        const raw = execFileSync("/usr/bin/tail", ["-n", "200", join(dir, f)], {
+            encoding: "utf8",
+            timeout: 4_000,
+            maxBuffer: 8 * 1024 * 1024,
+        });
+        let at = -1;
+        for (const line of raw.split("\n")) {
+            try {
+                const j = JSON.parse(line);
+                if ((j.type === "assistant" || j.type === "user") && j.timestamp)
+                    at = Date.parse(j.timestamp);
+            }
+            catch { /* blank or truncated line */ }
+        }
+        if (!best || at > best.at)
+            best = { file: f, raw, at };
+    }
+    return best;
+}
 function transcriptReading(claudePid) {
     const none = { working: null, doing: null, contextK: null, lastAt: null };
     try {
         const dir = projectTranscriptDir(claudePid);
         if (!dir)
             return none;
-        // The live transcript is the one being written. Newest wins; a session that
-        // has not written for a long time will show that in its own timestamp
-        // rather than being silently mistaken for a fresh one.
-        const newest = readdirSync(dir)
-            .filter((f) => f.endsWith(".jsonl"))
-            .map((f) => ({ f, m: statSync(join(dir, f)).mtimeMs }))
-            .sort((a, b) => b.m - a.m)[0];
-        if (!newest)
+        const picked = liveTranscriptTail(dir);
+        if (!picked)
             return none;
-        // Only the tail is needed and these files reach tens of megabytes.
-        const raw = execFileSync("/usr/bin/tail", ["-n", "40", join(dir, newest.f)], {
-            encoding: "utf8",
-            timeout: 4_000,
-            maxBuffer: 8 * 1024 * 1024,
-        });
+        const raw = picked.raw;
         const msgs = [];
         for (const line of raw.split("\n")) {
             if (!line.trim())
@@ -1727,19 +1750,17 @@ export function writeStandingRules(text, path = RULES_FILE) {
  */
 const GOAL_MAX_CHARS = 3800;
 /**
- * The most a LINE TYPED AT A SESSION may be, in characters — much stricter
- * than GOAL_MAX_CHARS above, and for a different reason.
+ * The most a LINE TYPED AT A SESSION may be, in characters.
  *
- * Proven from a live transcript on 2026-09-24: on Claude Code 2.1.280,
- * pasting text over roughly this length gets converted into a
- * `<pasted_content>` attachment instead of typed input, so a leading `/goal`
- * is never read as a slash command — the whole thing lands as one plain
- * message ("[Pasted text #N]"), the session answers "Noted.", and no goal is
- * set at all. A ~1,150-char line failed this way that night; a ~900-char
- * line of the same shape still typed correctly on Claude Code 2.1.267 the
- * night before. 700 leaves headroom under both observed points.
+ * Measured twice: above roughly 300 characters the prompt turns the typed
+ * `/goal` into a pasted attachment, Enter never submits it, and the text sits
+ * in the operator's input line while the log says "armed". Only a short line
+ * arms. Everything long goes to a brief file the line points at (see
+ * {@link buildGoalLine}); 250 leaves headroom under the measured point.
  */
-const GOAL_LINE_MAX_CHARS = 700;
+const GOAL_LINE_MAX_CHARS = 250;
+/** Where per-session briefs are written. */
+const BRIEF_DIR = join(homedir(), ".aibroker", "manage-briefs");
 /** `/goal` plus whichever of the given bits are non-empty, one line, no doubled spaces. */
 function assembleGoalLine(agentish, objective, rulesPointer, screenGrant) {
     const bits = [agentish, objective, rulesPointer, screenGrant].filter((s) => s.length > 0);
@@ -1981,65 +2002,91 @@ function screenStatus(m, now = Date.now()) {
     }
     return `screen: granted until ${at(lease.until)}, but ${describeControls(tool, now).replace(/^screen: /, "")} — renewing`;
 }
+/** A file-name-safe slug for a session, stable across armings. */
+export function briefSlug(m) {
+    const slug = (m.name || "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+    return slug || m.sessionId.replace(/[^a-zA-Z0-9]+/g, "").slice(0, 40) || "session";
+}
+/**
+ * The line typed at the session: `/goal` plus a pointer to the brief, plus as
+ * much of the objective's first words as fits. Never longer than `max`.
+ */
+export function buildGoalLine(briefPath, objective, max = GOAL_LINE_MAX_CHARS) {
+    const head = `/goal Follow ${briefPath} until done`;
+    const room = max - head.length - 2;
+    const words = oneLine(objective);
+    return room >= 20 && words ? `${head}: ${truncateAtWord(words, room)}` : head;
+}
+/** Everything that does not fit on the typed line, as the file it points to. */
+export function buildBrief(parts) {
+    const sections = [];
+    if (parts.agentish)
+        sections.push(`## Message format between agents\n\n${parts.agentish}`);
+    sections.push(`## Objective\n\n${parts.objective}`);
+    if (parts.shiftRules)
+        sections.push(`## Shift rules\n\n${parts.shiftRules}`);
+    if (parts.rulesSource) {
+        sections.push(`## Standing rules\n\nFIRST, before anything else: read ${parts.rulesSource} and follow every rule in it for the whole of this work — they are not optional and they are not summarised here.`);
+    }
+    if (parts.hands.trim())
+        sections.push(`## Screen\n\n${parts.hands.trim()}`);
+    if (parts.pending.length) {
+        sections.push(`## Operator notes since you were last armed\n\n${parts.pending.map((p) => `- ${p}`).join("\n")}`);
+    }
+    return `${sections.join("\n\n")}\n`;
+}
 /**
- * The text actually typed at the session, and the fragment to look for
- * afterwards to know it landed.
+ * The line typed at the session, after rewriting its brief file (0600).
  *
- * Short goal, context by reference — and, since GOAL_LINE_MAX_CHARS, always
- * a pointer to the rules rather than the rules themselves: inlining a real
- * standing-rules paragraph cannot fit a 700-char paste-safe budget anyway, so
- * there is no case left where trying the longer composeGoal() inline form
- * first would help.
+ * Rewritten on every arming so standing rules, shift state, the screen grant
+ * and pending operator notes are always current; pending notes are consumed
+ * into the brief, not the line.
  */
 function goalText(m) {
-    const extra = m.pending.length ? ` OPERATOR, since you were last armed: ${m.pending.join(" ")}` : "";
-    // The screen rule has to ride along with EVERY arming. Delivered once, it
-    // lasts only until the session next reads a goal — and the goal is what tells
-    // it what to do. So a standing rule that is not in the goal is a rule with a
-    // lifetime of one turn, and the next arming would send it back to clicking.
-    //
-    // The positive case has to ride along too, and for a sharper reason. Silence
-    // about the screen is not neutral: a session that has been careful with the
-    // operator's machine all night reads it as permission having quietly ended,
-    // and one of them announced it had handed the controls back while the grant
-    // on disk still had two hours on it. Saying the expiry out loud, every time,
-    // is what stops a session inventing one.
-    //
-    // `rules clear` is the operator saying objectives now carry only themselves,
-    // so the screen guidance goes with the rest of the standing prose and only
-    // the expiry rides along. The prohibition below is NOT shortened with it: a
-    // goal template that hands the screen over says nothing about the case where
-    // the screen is withheld, so that guidance exists nowhere else.
     const rules = readStandingRules();
+    // The screen rule rides along with EVERY arming: delivered once it lasts
+    // only until the session next reads a goal, and silence about the screen is
+    // read as permission having quietly ended. Now it lives in the brief.
     const hands = m.noScreen
-        ? " THE OPERATOR HAS THE SCREEN: do no screen or pointer work at all, and do not ask for it. Everything else continues as normal. Where something would need checking on screen, write down what would need checking instead of checking it."
+        ? "THE OPERATOR HAS THE SCREEN: do no screen or pointer work at all, and do not ask for it. Everything else continues as normal. Where something would need checking on screen, write down what would need checking instead of checking it."
         : (() => {
             const lease = screenLease(m, Date.now());
             return lease ? screenGrantedClause(lease.until, !rules) : "";
         })();
-    // AG2 goes first, ahead of the objective and the standing rules, on every
-    // arming — not once at setup. A managed session works unattended for hours
-    // and a reminder given only at the start does not survive a compaction or a
-    // `/clear`. What a managed session sends the operator, and what it commits
-    // to git, stays prose either way — AG2 is only how agents talk to agents.
-    const rulesPointer = rules
-        ? `FIRST, before anything else: read ${standingRulesSource()} and follow every rule in it for the whole of this work — they are not optional and they are not summarised here.`
-        : "";
-    const fit = fitGoal({ objective: `${m.objective}${extra}`, agentish: AG2_SPEC, rulesPointer, screenGrant: hands }, GOAL_LINE_MAX_CHARS);
-    return { text: fit.line, fragment: fit.objective.slice(0, 40) };
-}
-/**
- * Did it land? Look for the goal's own words in the transcript.
- *
- * NOT "did the content change" — that was the first version and it could not
- * tell a goal that arrived from text stranded unsubmitted in the input line,
- * which is the exact failure it existed to catch. A session prints for a dozen
- * reasons; only the item's own words say the item is there.
- */
-function seenInContent(content, fragment) {
-    if (!content)
-        return false;
-    return content.replace(/\s+/g, "").includes(fragment.replace(/\s+/g, ""));
+    const shift = shiftObjective();
+    const path = join(BRIEF_DIR, `${briefSlug(m)}.md`);
+    mkdirSync(BRIEF_DIR, { recursive: true, mode: 0o700 });
+    writeFileSync(path, buildBrief({
+        objective: m.objective,
+        agentish: AG2_SPEC,
+        rulesSource: rules ? standingRulesSource() : "",
+        shiftRules: m.shift && m.objective !== shift ? shift : "",
+        hands,
+        pending: m.pending,
+    }), { mode: 0o600 });
+    chmodSync(path, 0o600);
+    return { text: buildGoalLine(foldHome(path), m.objective) };
+}
+/**
+ * Did it arm? Within a bounded wait the pane must show the goal marker with an
+ * empty input line. If our own line is still sitting in the input, it is
+ * cleared — never left in the operator's prompt — and the arm counts as failed.
+ *
+ * Text is not proof of a landing (a stranded line shows up in the transcript
+ * area too, which is what the earlier fragment check could not tell apart).
+ */
+export async function confirmArmed(typed, deps, waits = 5, waitMs = 2_000) {
+    let unsent = null;
+    for (let i = 0; i < waits; i++) {
+        await deps.sleep(waitMs);
+        const pane = deps.readPane();
+        unsent = promptUnsentText(pane);
+        if (GOAL_ACTIVE.test(pane) && !unsent)
+            return true;
+    }
+    if (unsent && typedLineMatches(unsent, typed))
+        deps.clearInput();
+    return false;
 }
 function readPane(sessionId, opts = {}) {
     try {
@@ -2053,7 +2100,7 @@ async function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
 async function arm(m, reason) {
-    const { text, fragment } = goalText(m);
+    const { text } = goalText(m);
     /**
      * NEVER TYPE A GOAL INTO A BARE SHELL.
      *
@@ -2155,22 +2202,20 @@ async function arm(m, reason) {
     }
     sendEnterKey(m.sessionId);
     // Typed is not sent, and sent is not received.
-    for (let i = 0; i < 5; i++) {
-        await sleep(2_000);
-        if (seenInContent(readPane(m.sessionId, { fresh: true }), fragment)) {
-            m.lastRearmAt = Date.now();
-            const carried = m.pending.length;
-            m.pending = [];
-            armingsSinceReport.set(m.sessionId, (armingsSinceReport.get(m.sessionId) ?? 0) + 1);
-            // The read-back above already confirmed the line held exactly what was
-            // typed before CR ever went out, so there is nothing left here to weld
-            // a goal onto — unlike before any of this guard existed, this note
-            // never has an "input line held X" case left to report.
-            note(m, `armed: ${reason}${carried ? ` (carrying ${carried} operator instruction${carried > 1 ? "s" : ""})` : ""}`);
-            return true;
-        }
+    const landed = await confirmArmed(text, {
+        readPane: () => readPane(m.sessionId, { fresh: true }),
+        sleep,
+        clearInput: () => sendControlU(m.sessionId),
+    });
+    if (landed) {
+        m.lastRearmAt = Date.now();
+        const carried = m.pending.length;
+        m.pending = [];
+        armingsSinceReport.set(m.sessionId, (armingsSinceReport.get(m.sessionId) ?? 0) + 1);
+        note(m, `armed: ${reason}${carried ? ` (carrying ${carried} operator instruction${carried > 1 ? "s" : ""})` : ""}`);
+        return true;
     }
-    notify(m, `typed but the objective's own words never appeared — treating as NOT armed (${reason})`);
+    notify(m, `typed but the goal never took (no active marker, or the line stayed in the input) — input cleared, treating as NOT armed (${reason})`);
     return false;
 }
 /**
@@ -3038,6 +3083,9 @@ export async function handleManage(sessionIdOrName, rawArg) {
             message: `manage — keep a session working on a standing objective.\n\n` +
                 `  <objective>   start managing, or once running, an instruction carried\n` +
                 `                into the next arming ("do the tests before the docs")\n` +
+                `  start <text>  start managing, or REPLACE the objective when already managed\n` +
+                `  instruct <text>\n` +
+                `                a one-shot note for the next arming (same as plain text)\n` +
                 `  status        what the session looks like right now, and what the\n` +
                 `                manager has done. Also: state, what, info, show\n` +
                 `  hands off     the operator needs the screen: stops visual work at once,\n` +
@@ -3174,8 +3222,8 @@ export async function handleManage(sessionIdOrName, rawArg) {
         }
         const { hours, visual, workers } = parseShift(rest);
         const until = Date.now() + hours * 3_600_000;
-        existing.objective = shiftObjective();
-        existing.pending = [];
+        if (!existing.objective.trim())
+            existing.objective = shiftObjective();
         existing.paused = false;
         existing.noScreen = !visual;
         existing.handsUntil = until;
@@ -3211,7 +3259,7 @@ export async function handleManage(sessionIdOrName, rawArg) {
             message: `${name} is on shift for ${hours} hour(s), until ${ends}.\n` +
                 `  ${visual ? "The screen is its own until then, and reverts by itself." : "No screen work — the operator has the machine."}\n` +
                 screenLine +
-                `  Objective set to the tracker's open issues; the standing rules ride along with every arming.\n` +
+                `  ${existing.objective === shiftObjective() ? "Objective set to the tracker's open issues" : "Objective kept, the shift's issue-work rules go in the brief"}; the standing rules ride along with every arming.\n` +
                 (workers > 1
                     ? `  Asked for ${workers} workers. Only one runs today — worktrees and the claim protocol are designed but not built, and a second worker without them would share a checkout with the first.\n`
                     : "") +
@@ -3280,7 +3328,7 @@ export async function handleManage(sessionIdOrName, rawArg) {
      * rather than misleading once. That is the difference between an objective
      * and a message, and it is why this needs its own verb.
      */
-    const setMatch = arg.match(/^(?:set|objective|replace)\s+([\s\S]+)$/i);
+    const setMatch = arg.match(/^(?:set|objective|replace|start)\s+([\s\S]+)$/i);
     if (setMatch && existing) {
         const before = existing.objective;
         existing.objective = setMatch[1].trim();
@@ -3562,10 +3610,11 @@ export async function handleManage(sessionIdOrName, rawArg) {
                     `If you meant a different session, name it first: aibroker manage <session> <objective>`,
             };
         }
+        const objective = arg.match(/^start\s+([\s\S]+)$/i)?.[1].trim() ?? arg;
         const m = {
             sessionId,
             name,
-            objective: arg,
+            objective,
             pending: [],
             history: [],
             // Give the session the benefit of the grace period rather than arming
@@ -3587,7 +3636,7 @@ export async function handleManage(sessionIdOrName, rawArg) {
         return {
             ok: true,
             managed: true,
-            message: `managing ${name}. It will be re-armed with this objective whenever it stops:\n  ${arg}`,
+            message: `managing ${name}. It will be re-armed with this objective whenever it stops:\n  ${objective}`,
         };
     }
     if (word === "now") {
@@ -3595,8 +3644,9 @@ export async function handleManage(sessionIdOrName, rawArg) {
         saveState(state);
         return { ok: true, managed: true, message: `${name} will be armed on the next tick` };
     }
-    existing.pending.push(arg);
-    note(existing, `operator: ${arg.slice(0, 80)}`);
+    const instruction = arg.match(/^instruct\s+([\s\S]+)$/i)?.[1].trim() ?? arg;
+    existing.pending.push(instruction);
+    note(existing, `operator: ${instruction.slice(0, 80)}`);
     saveState(state);
     return {
         ok: true,