tryharness 0.5.1 → 0.6.0

package/README.md

@@ -73,7 +73,14 @@ machine with `--run --workspace <dir>` (or an agent's `run_workspace` request, o
 authorizes it with `tryharness board run <id>`) is claimed by the daemon in that agent's name,
 run non-interactively through the same runner as a delegated run, and reported back on the
 task with the result and the agent's session id; `tryharness task <id> --follow` works on it.
-One run per agent at a time; a daemon restart marks a running task unknown. An interactive
+One run per agent at a time; a daemon restart marks a running task unknown.
+A coding agent also starts, without `board run`, the tasks you or Harness post for it with a workspace in a
+folder it has already worked in (its indexed sessions; your home folder counts only as itself, links are
+followed), up to 10 a day. That is on by default, and the daemon says so once when it first starts with it. A
+task another agent wrote, or one Harness posts from a turn you did not start or while working another agent's
+task, always waits for you. `tryharness board standing` shows it; `tryharness board standing <agent> <folder>...
+[--cap <n>]` names the folders instead; `tryharness board standing <agent> off` and `on` turn it off or back to
+the default. An interactive
 claim carries a lease (default 60 minutes); a lapsed lease shows the claim as stale and only
 the poster or the user releases it. `tryharness board agents` shows when each agent last read
 the board. Every change goes up the bridge as identity and status only.

package/cli.mjs

@@ -171,6 +171,7 @@ async function connect() {
     throw new Error(`setup is incomplete for ${failed.map((state) => state.agent).join(", ")}. Nothing was hidden; run npx tryharness doctor after fixing the reported CLI error, then rerun setup.`);
   }
   console.log("history: indexing locally in the background");
+  console.log("runs: your coding agents start the tasks you ask for in folders they have worked in, up to 10 a day each, without a Start; tasks another agent wrote wait for you. Change it: npx tryharness board standing");
   console.log("Done. You can close this terminal.");
 }
 
@@ -316,6 +317,30 @@ async function board() {
     for (const entry of response.entries) console.log(`\n[${entry.kind} · ${entry.author}${entry.source ? ` · ${entry.source}` : ""} · ${entry.score}]\n${entry.text.slice(0, 400)}`);
     return;
   }
+  // Standing permission: a coding agent starts the tasks you or Harness post for it without a Start. On by default
+  // for the folders you have used it in; name folders and a daily cap instead, turn it off, or back on to the default.
+  // Tasks another agent wrote always wait for you.
+  if (sub === "standing") {
+    const rest = argv.slice(argv.indexOf(sub) + 1).filter((value, index, all) => !value.startsWith("--") && all[index - 1] !== "--cap" && all[index - 1] !== "--as");
+    const [target, ...dirs] = rest;
+    const usage = "usage: tryharness board standing [<agent> <folder> [<folder>...] [--cap <runs a day, default 10>] | <agent> off | <agent> on]";
+    if (target && !AGENTS.includes(target)) throw new Error(usage);
+    const toggle = dirs.length === 1 && ["on", "off"].includes(dirs[0]) ? dirs[0] : null;
+    const response = !target ? await daemonRequest({ command: "board.standing", agent })
+      : toggle ? await daemonRequest({ command: `board.standing.${toggle}`, agent, targetAgent: target })
+        : dirs.length ? await daemonRequest({ command: "board.standing.set", agent, targetAgent: target, workspaces: dirs.map((dir) => path.resolve(dir)), dailyCap: Number(arg("--cap", "10")) })
+          : (() => { throw new Error(usage); })();
+    if (!response.ok) throw new Error(response.error || "standing permission failed");
+    if (!response.standing.length) { console.log("No coding agent is installed on this machine."); return; }
+    for (const rule of response.standing) {
+      if (rule.mode === "off") { console.log(`${rule.agent} waits for your Start. Turn it on: npx tryharness board standing ${rule.agent} on`); continue; }
+      const where = rule.mode === "default"
+        ? (rule.workspaces.length ? `in the ${rule.workspaces.length} folder${rule.workspaces.length === 1 ? "" : "s"} you have used it in (${rule.workspaces.slice(0, 5).join(", ")}${rule.workspaces.length > 5 ? ", ..." : ""})` : "in folders you have used it in (none yet)")
+        : `in ${rule.workspaces.join(", ")}`;
+      console.log(`${rule.agent} starts tasks from you or Harness without asking, ${where}; ${rule.runs_today} of ${rule.daily_cap} today. Turn it off: npx tryharness board standing ${rule.agent} off`);
+    }
+    return;
+  }
   if (sub === "run" || sub === "release") {
     const id = String(argv[argv.indexOf(sub) + 1] || "");
     const response = await daemonRequest({ command: sub === "run" ? "board.run" : "board.release", agent, id });
@@ -379,7 +404,7 @@ async function board() {
     for (const wait of t.waiting_on) console.log(`waiting: ${wait.id.slice(0, 8)} is ${wait.status}${wait.holder ? ` with ${wait.holder}` : ""}`);
     return;
   }
-  if (sub !== "list") throw new Error("usage: tryharness board [list --all | show <id> | trace <id> | post --for <agent> --objective <text> [--file <brief.md>] [--run --workspace <dir>] | run <id> | release <id> | agents]");
+  if (sub !== "list") throw new Error("usage: tryharness board [list --all | show <id> | trace <id> | post --for <agent> --objective <text> [--file <brief.md>] [--run --workspace <dir>] | run <id> | release <id> | standing [<agent> <folder>... --cap <n> | <agent> off | <agent> on] | agents]");
   const response = await daemonRequest({ command: "board.list", agent, all: has("--all") });
   if (!response.ok) throw new Error(response.error || "board unavailable");
   if (!response.tasks.length) { console.log("The board is empty."); return; }

package/lib/daemon.mjs

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import net from "node:net";
+import os from "node:os";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
@@ -343,6 +344,37 @@ export async function startDaemon() {
   // Tasks written before the context space existed get their brief and result as entries.
   for (const id of store.backfillContributions()) log(`context: backfilled task ${id}`);
 
+  // Standing permission, decided when a task is posted: a run the person asked for (themselves or through Harness),
+  // for a coding agent installed here, in a folder the permission covers, under today's cap, starts without a Start.
+  // By default it covers the folders the person has already used that agent in; home and anything above it count only
+  // as themselves, never as a root. Anything another agent wrote never starts. Links are followed, so no path inside a
+  // covered folder leads out of it.
+  const RUNNERS = new Set(["claude-code", "codex", "pi", "opencode"]);
+  const runners = () => installedAgents.filter((agent) => RUNNERS.has(agent));
+  const startOfToday = () => { const day = new Date(); day.setHours(0, 0, 0, 0); return day.toISOString(); };
+  const realDir = (dir) => { try { return fs.realpathSync(dir); } catch { return path.resolve(dir); } };
+  const within = (dir, root) => { const rel = path.relative(realDir(root), realDir(dir)); return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel)); };
+  const aboveHome = (dir) => within(os.homedir(), dir);
+  const covers = (rule, dir) => rule.workspaces.some((root) => rule.mode === "default" && aboveHome(root) ? realDir(root) === realDir(dir) : within(dir, root));
+  const standingRules = () => store.standing(runners(), startOfToday());
+  // null when the run may start now; otherwise why it waits for the person.
+  const standingVerdict = ({ trust, target, workspace }) => {
+    if (trust !== "user") return "Another agent wrote it, so it never starts without the person.";
+    const rule = standingRules().find((entry) => entry.agent === target);
+    if (!rule) return `${target} is not a coding agent installed on this machine.`;
+    if (rule.mode === "off") return `${target} is set to wait for the person's Start.`;
+    if (!covers(rule, workspace)) return rule.mode === "default" ? `${target} has not worked in ${workspace} before, so its first run there waits for the person.` : `${workspace} is outside the folders ${target} may run in without asking (${rule.workspaces.join(", ")}).`;
+    if (rule.runs_today >= rule.daily_cap) return `${target} already started ${rule.runs_today} runs today without asking, its daily limit.`;
+    return null;
+  };
+  const applyStanding = (task) => {
+    if (!task?.run_workspace || task.run_authorized_at) return undefined;
+    const start = `It waits for the person's Start on the Harness Board, or: npx tryharness board run ${task.id}`;
+    const reason = standingVerdict({ trust: task.trust, target: task.target_agent, workspace: task.run_workspace });
+    if (reason) return { started: false, reason: `${reason} ${start}` };
+    return store.authorizeStanding(task.id) ? { started: true } : { started: false, reason: `It could not be authorized. ${start}` };
+  };
+
   const boardCommand = (request) => {
     if (!validAgent(request.agent)) return { ok: false, error: "board requests need an agent name" };
     const agent = String(request.agent);
@@ -371,6 +403,11 @@ export async function startDaemon() {
       if (request.id != null && !validRunId(request.id)) return { ok: false, error: "invalid task id" };
       if (request.id != null && store.getTask(String(request.id))) return { ok: false, error: "a task with this id already exists", task: store.getTask(String(request.id)) };
       const thread = request.thread && typeof request.thread === "object" ? request.thread : null;
+      // A run asked for now, covered or not posted at all: nothing is left waiting that the person did not see.
+      if (request.requireStanding === true) {
+        const reason = thread || !runWorkspace || !request.targetAgent ? "a run without a Start needs one target agent and a folder" : standingVerdict({ trust: provenance.trust, target: String(request.targetAgent), workspace: runWorkspace });
+        if (reason) return { ok: false, error: reason, standing: { started: false, reason } };
+      }
       if (thread && (!validAgent(thread.with) || !["asker", "target"].includes(thread.role))) return { ok: false, error: "a thread needs the other side's agent and a role" };
       // Several agents at once: one group task with a part per agent.
       const targetAgents = Array.isArray(request.targetAgents) ? [...new Set(request.targetAgents.map(String))] : null;
@@ -381,7 +418,7 @@ export async function startDaemon() {
         else {
           const posted = store.postGroup({ ...(request.id != null ? { id: String(request.id) } : {}), objective: objective.slice(0, 500), brief: String(request.brief || "").slice(0, 200_000), originAgent: agent, provenance,
             targetAgents, contextRefs: refs, runWorkspace, runAuthorizedBy: runWorkspace && agent === "user" ? "user" : null });
-          for (const part of posted.children) notifyBoard(store.getTask(part.id));
+          for (const part of posted.children) { applyStanding(store.getTask(part.id)); notifyBoard(store.getTask(part.id)); }
           notifyBoard(posted.group);
           return { ok: true, task: posted.group };
         }
@@ -390,7 +427,8 @@ export async function startDaemon() {
         originAgent: agent, provenance, targetAgent: request.targetAgent ? String(request.targetAgent) : null, parentId: request.parentId ? String(request.parentId) : null, contextRefs: refs,
         runWorkspace: thread ? null : runWorkspace, runAuthorizedBy: !thread && runWorkspace && agent === "user" ? "user" : null });
       if (thread) store.openThread(task.id, { withAgent: String(thread.with), role: thread.role });
-      outcome = { ok: true, task: store.getTask(task.id), thread: thread ? store.getThread(task.id) : null };
+      const standing = thread ? undefined : applyStanding(task);
+      outcome = { ok: true, task: store.getTask(task.id), thread: thread ? store.getThread(task.id) : null, ...(standing ? { standing } : {}) };
     } else if (request.command === "board.list") {
       const tasks = store.listTasks({ agent, status: request.status ? String(request.status) : undefined, all: request.all === true, limit: request.limit });
       return request.unread ? { ok: true, tasks, unread: store.unreadFor(agent) } : { ok: true, tasks };
@@ -438,6 +476,28 @@ export async function startDaemon() {
     } else if (request.command === "board.children") return { ok: true, tasks: store.children(id).map((child) => store.getTask(child.id)).filter(Boolean) };
     // A trace reads both homes, and only Harness can: the machine asks it.
     else if (request.command === "board.trace") return state.connected ? forwardToHarness(request) : { ok: false, error: "a trace reads the whole chain on this machine and in Harness, and the daemon is not connected to Harness right now" };
+    else if (request.command === "board.standing") return { ok: true, standing: standingRules() };
+    else if (request.command === "board.standing.check") {
+      const reason = standingVerdict({ trust: "user", target: String(request.targetAgent || ""), workspace: String(request.workspace || "") });
+      return path.isAbsolute(String(request.workspace || "")) ? { ok: true, covered: !reason, ...(reason ? { reason } : {}) } : { ok: false, error: "a folder must be an absolute path" };
+    }
+    else if (["board.standing.set", "board.standing.off", "board.standing.on"].includes(request.command)) {
+      if (agent !== "user") return { ok: false, error: "only the person changes standing permission" };
+      const target = String(request.targetAgent || "");
+      if (!RUNNERS.has(target)) return { ok: false, error: `standing permission is for a coding agent: ${[...RUNNERS].join(", ")}` };
+      if (request.command === "board.standing.off") store.setStanding(target, "off");
+      else if (request.command === "board.standing.on") store.resetStanding(target);
+      else {
+        const workspaces = Array.isArray(request.workspaces) ? [...new Set(request.workspaces.map(String))] : [];
+        if (!workspaces.length || workspaces.length > 20) return { ok: false, error: "name one to twenty folders" };
+        const bad = workspaces.find((dir) => !path.isAbsolute(dir) || !fs.statSync(dir, { throwIfNoEntry: false })?.isDirectory());
+        if (bad) return { ok: false, error: `${bad} is not an absolute path to a folder` };
+        const dailyCap = Number(request.dailyCap);
+        if (!Number.isInteger(dailyCap) || dailyCap < 1 || dailyCap > 100) return { ok: false, error: "the daily limit is a whole number from 1 to 100" };
+        store.setStanding(target, "named", workspaces.map((dir) => path.resolve(dir)), dailyCap);
+      }
+      return { ok: true, standing: standingRules() };
+    }
     else if (request.command === "board.agents") return { ok: true, agents: store.agentsSeen(), running: [...activeRuns.entries()].map(([runAgent, taskId]) => ({ agent: runAgent, id: taskId })) };
     else if (["board.claim", "board.report", "board.answer", "board.release"].includes(request.command) && !store.getTask(id) && state.connected) return forwardToHarness(request);
     else if (request.command === "board.claim") outcome = store.claimTask(id, agent, expected, Number.isInteger(request.leaseMinutes) ? request.leaseMinutes : 60);
@@ -456,6 +516,13 @@ export async function startDaemon() {
   // agent at a time; the rest wait open. Nothing here polls: a board write calls runBoard.
   const activeRuns = new Map();
   for (const id of store.settleInterruptedRuns()) log(`board task ${id} was running when the daemon stopped; marked unknown`);
+  // Standing permission is on by default; the person hears so once, on the first start that has it.
+  const defaults = standingRules().filter((rule) => rule.mode === "default");
+  if (defaults.length && !store.meta("standing_announced")) {
+    const one = defaults.length === 1;
+    const text = `${defaults.map((rule) => rule.agent).join(", ")} now ${one ? "starts" : "start"} the tasks you ask for in folders ${one ? "it has" : "they have"} worked in, up to ${defaults[0].daily_cap} a day${one ? "" : " each"}, without a Start. Change it: npx tryharness board standing`;
+    log(text); notifyDesktop(text); store.meta("standing_announced", new Date().toISOString());
+  }
   const runBoard = () => {
     for (const task of store.runnableTasks(installedAgents.filter((agent) => !activeRuns.has(agent)))) {
       const agent = task.target_agent;

package/lib/store.mjs

@@ -16,6 +16,8 @@ function bindings(values) {
   )));
 }
 
+export const DEFAULT_DAILY_RUNS = 10;
+
 export function openStore(file) {
   const db = new Database(file);
   // The daemon is the database's single writer. DELETE mode is portable across the
@@ -80,6 +82,17 @@ export function openStore(file) {
       updated_at text not null
     );
     create index if not exists board_tasks_status_idx on board_tasks(status, created_at desc);
+    create table if not exists board_standing (
+      agent text primary key,
+      mode text not null,
+      workspaces text not null,
+      daily_cap integer not null,
+      set_at text not null
+    );
+    create table if not exists board_meta (
+      key text primary key,
+      value text not null
+    );
     create table if not exists board_agents (
       agent text primary key,
       last_seen_at text not null
@@ -133,6 +146,7 @@ export function openStore(file) {
   }
   // Boards written before the lock existed: give every task a holder and a version.
   const boardColumns = new Set(db.all("pragma table_info(board_tasks)").map((column) => column.name));
+  if (!db.all("pragma table_info(board_standing)").some((column) => column.name === "mode")) db.exec("alter table board_standing add column mode text not null default 'named'");
   if (!boardColumns.has("holder")) {
     db.exec(`alter table board_tasks add column holder text;
       alter table board_tasks add column version integer not null default 1;
@@ -344,6 +358,38 @@ export function openStore(file) {
       if (written.changes === 1) return { ok: true, task: this.getTask(id) };
       return conflict(this.getTask(id), agent, null, (task) => task.run_authorized_at ? "the run is already authorized" : !task.run_workspace ? "this task did not ask for a run" : `task is ${task.status}`);
     },
+    // Standing permission: an agent starts the work the person or Harness posts for it without a Start each time. By
+    // default it covers the folders the person has used that agent in (its indexed sessions); the person can name
+    // folders instead (mode 'named') or turn it off ('off'). Only the person changes it; the daemon decides each post.
+    setStanding(agent, mode, workspaces = [], dailyCap = DEFAULT_DAILY_RUNS) {
+      execute("run", `insert into board_standing(agent, mode, workspaces, daily_cap, set_at) values(?, ?, ?, ?, ?)
+        on conflict(agent) do update set mode = excluded.mode, workspaces = excluded.workspaces, daily_cap = excluded.daily_cap, set_at = excluded.set_at`,
+        agent, mode, JSON.stringify(workspaces), dailyCap, new Date().toISOString());
+    },
+    resetStanding(agent) {
+      return execute("run", "delete from board_standing where agent = ?", agent).changes === 1;
+    },
+    // One rule per agent installed here, with the runs it started since `since`.
+    standing(agents, since) {
+      const rows = new Map(execute("all", "select * from board_standing").map((row) => [row.agent, row]));
+      return agents.map((agent) => {
+        const row = rows.get(agent);
+        const mode = row?.mode || "default";
+        const workspaces = mode === "default" ? execute("all", "select distinct cwd from sessions where agent = ? and cwd is not null and cwd != '' order by cwd", agent).map((entry) => entry.cwd) : JSON.parse(row.workspaces);
+        return { agent, mode, workspaces, daily_cap: row ? Number(row.daily_cap) : DEFAULT_DAILY_RUNS, set_at: row?.set_at || null,
+          runs_today: Number(execute("get", "select count(*) as n from board_tasks where target_agent = ? and run_authorized_by = 'standing' and run_authorized_at >= ?", agent, since).n) };
+      });
+    },
+    meta(key, value) {
+      if (value === undefined) return execute("get", "select value from board_meta where key = ?", key)?.value ?? null;
+      execute("run", "insert into board_meta(key, value) values(?, ?) on conflict(key) do update set value = excluded.value", key, String(value));
+    },
+    authorizeStanding(id) {
+      const now = new Date().toISOString();
+      const written = execute("run", `update board_tasks set run_authorized_by = 'standing', run_authorized_at = @now, updated_at = @now, version = version + 1
+        where id = @id and status = 'open' and trust = 'user' and run_workspace is not null and run_authorized_at is null and id not in (select task_id from board_threads)`, { id, now });
+      return written.changes === 1;
+    },
     // Tasks the daemon should run now: authorized, still open, for an agent installed here.
     runnableTasks(agents) {
       if (!agents.length) return [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tryharness",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Harness Relay: the daemon that turns the agents on this machine into your personal swarm. Memory, history, and work handed between any of them.",
   "bin": {
     "tryharness": "cli.mjs"