@inhuman.tools/turn 0.0.0-stage → 0.1.0

package/src/session/commands.ts

@@ -0,0 +1,292 @@
+/**
+ * Session commands: turn admit (mint/steer/queue/continue), compact, cancel,
+ * rewind, retry, and prompt-queue drain. Transport and document persistence
+ * stay on the host.
+ */
+import { asSystemPrompt, asUserPrompt, type UserPrompt } from "@inhuman.tools/harness-commons";
+import {
+  admitQueue,
+  admitSteer,
+  CompactJob,
+  findEvalTurnByRequestId,
+  findTurnById,
+  HOST_QUEUE_VERBS,
+  isAtTip,
+  isRewindPin,
+  looksLikePath,
+  onTipChain,
+  reactChunks,
+  ReACTChunk,
+  refreshSystemPrompt,
+  resolvedTip,
+  SessionSystemPrompt,
+  SessionTurn,
+  skillMatchesVerb,
+  tapeCompletion,
+  userVisualsJson,
+  type UserVisualIdentity,
+} from "@inhuman.tools/harness-model";
+
+import type { SessionCommandHost } from "./types.js";
+import { compactRejectReason, stampCompactInputs } from "../context/index.js";
+
+export type CommandFail = {
+  readonly ok: false;
+  readonly reason: string;
+  readonly invalid?: boolean;
+};
+
+export type TurnAdmitResult =
+  | {
+      readonly ok: true;
+      readonly action: "noop" | "mint" | "steer" | "queue" | "continue";
+    }
+  | CommandFail;
+
+export type CompactAdmitResult = { readonly ok: true; readonly compacted: false } | CommandFail;
+
+export type RewindResult = { readonly ok: true; readonly turnId: string } | CommandFail;
+
+export type CancelTurnArgs = { readonly turnId: string } | { readonly requestId: string };
+
+type TurnKind = "steer" | "queue" | "continue";
+
+function requestTurnCancel(turn: SessionTurn, requestId?: string, cancelledEval?: Record<string, string>): void {
+  turn.cancelRequested = true;
+  if (requestId != null && requestId !== "" && cancelledEval != null) {
+    cancelledEval[requestId] = "1";
+  }
+}
+
+function refreshTurn(host: SessionCommandHost, turn: SessionTurn): void {
+  refreshSystemPrompt(turn, {
+    constitution: asSystemPrompt(host.constitution),
+    env: host.env(),
+  });
+  host.applyBotNotice?.(turn);
+}
+
+/** R1: the policy in force when the turn is minted. A later config or kv edit applies from the next turn. */
+function retentionStamp(host: SessionCommandHost): { readonly retentionJson?: string } {
+  const json = host.retentionJson?.() ?? "";
+  return json === "" ? {} : { retentionJson: json };
+}
+
+function mintContinueTurn(host: SessionCommandHost, head: SessionTurn): void {
+  const turn = new SessionTurn({
+    turnTail: head,
+    prompt: asUserPrompt(""),
+    queue: [new ReACTChunk()],
+    toolsDefinition: host.toolsFor(head),
+    ...retentionStamp(host),
+  });
+  host.session.seatHead(turn);
+  refreshTurn(host, turn);
+  host.log?.("continue admitted");
+}
+
+function skillSplit(
+  host: SessionCommandHost,
+  text: UserPrompt,
+): { readonly prompt: UserPrompt; readonly derived: UserPrompt | null } {
+  host.syncSkills?.();
+  return host.expandSkill?.(text, host.session.skills, host.queuedVerbs()) ?? { prompt: text, derived: null };
+}
+
+function mintUserTurn(
+  host: SessionCommandHost,
+  text: UserPrompt,
+  visuals: readonly UserVisualIdentity[] = [],
+): SessionTurn {
+  const split = skillSplit(host, text);
+  const tail =
+    host.session.head ??
+    new SessionSystemPrompt({
+      constitution: asSystemPrompt(host.constitution),
+      env: host.env(),
+      skills: host.session.skills.map((skill) => skill.clone()),
+    });
+  const turn = new SessionTurn({
+    turnTail: tail,
+    prompt: split.prompt,
+    derivedMessage: split.derived,
+    toolsDefinition: host.toolsFor(tail),
+    ...retentionStamp(host),
+    ...(visuals.length === 0 ? {} : { visualsJson: userVisualsJson(visuals) }),
+  });
+  turn.markStarted();
+  host.session.seatHead(turn);
+  refreshTurn(host, turn);
+  host.log?.(`turn ${text}`);
+  return turn;
+}
+
+function mintCompactTurn(host: SessionCommandHost, focus: string): CompactAdmitResult {
+  if (host.session.head == null) {
+    host.log?.("compact no-head");
+    return { ok: false, reason: "no-head" };
+  }
+  const rejected = compactRejectReason(host.session.head);
+  if (rejected != null) {
+    host.log?.(`compact ${rejected}`);
+    return { ok: false, reason: rejected };
+  }
+  const job = new CompactJob({ reason: "user" });
+  // F8: the cut's inputs are facts of this job from here on, not live settings.
+  stampCompactInputs(job, host.compactKeepTurns?.() ?? 1, host.session.kvs);
+  const turn = new SessionTurn({
+    turnTail: host.session.head,
+    prompt: asUserPrompt(focus),
+    queue: [job],
+    reloadTools: true,
+  });
+  turn.pushChild(job);
+  turn.markStarted();
+  host.session.seatHead(turn);
+  refreshTurn(host, turn);
+  host.log?.("compact admitted");
+  return { ok: true, compacted: false };
+}
+
+export function admitTurn(
+  host: SessionCommandHost,
+  args: { readonly prompt: string; readonly kind?: TurnKind; readonly visuals?: readonly UserVisualIdentity[] },
+): TurnAdmitResult {
+  const visuals = args.visuals ?? [];
+  const prompt = asUserPrompt(args.prompt.trim());
+  if (visuals.length > 0 && (args.kind === "steer" || args.kind === "queue" || args.kind === "continue")) {
+    return { ok: false, reason: "an image can't be sent with that", invalid: true };
+  }
+  if (args.kind === "continue") {
+    if (host.session.findRunningTurn() != null) return { ok: true, action: "noop" };
+    if (!isAtTip(host.session.head, host.session.tip)) {
+      return { ok: false, reason: "off-tip", invalid: true };
+    }
+    const head = host.session.head;
+    if (!head?.lastTurnIncomplete) return { ok: true, action: "noop" };
+    if ((host.session.kvs.connection ?? "").trim() === "") {
+      return { ok: false, reason: "connection is required", invalid: true };
+    }
+    mintContinueTurn(host, head);
+    return { ok: true, action: "continue" };
+  }
+  if (prompt === "" && visuals.length === 0) return { ok: true, action: "noop" };
+  if ((host.session.kvs.connection ?? "").trim() === "") {
+    return { ok: false, reason: "connection is required", invalid: true };
+  }
+  const running = host.session.findRunningTurn();
+  if (running != null) {
+    if (visuals.length > 0) return { ok: false, reason: "an image can't be sent with that", invalid: true };
+    // A steer is an expectation that the turn claims it at its next round.
+    // A turn that can't (stopped, an eval, a compact) won't, so the row is
+    // an expectation of a future turn instead: the queue lane, which the
+    // session mints from once that turn has exited.
+    const kind = args.kind !== "queue" && host.session.steerTurn === running ? "steer" : "queue";
+    const split = skillSplit(host, prompt);
+    if (kind === "queue") admitQueue(host.session, split.prompt, running.uuid, split.derived);
+    else admitSteer(host.session, split.prompt, running.uuid, split.derived);
+    host.log?.(`turn ${kind} ${prompt}`);
+    return { ok: true, action: kind };
+  }
+  mintUserTurn(host, prompt, visuals);
+  return { ok: true, action: "mint" };
+}
+
+export function admitCompact(host: SessionCommandHost, focus = ""): CompactAdmitResult {
+  if (host.session.findRunningTurn() != null) {
+    return { ok: false, reason: "already running", invalid: true };
+  }
+  return mintCompactTurn(host, focus);
+}
+
+export function cancelTurnCommand(host: SessionCommandHost, args: CancelTurnArgs): { readonly ok: true } {
+  if ("requestId" in args) {
+    const existing = findEvalTurnByRequestId(host.session, args.requestId);
+    if (existing != null) {
+      requestTurnCancel(existing, args.requestId, host.session.cancelledEvalRequests);
+      host.cancelOwned(existing);
+    } else {
+      host.session.cancelledEvalRequests[args.requestId] = "1";
+    }
+    host.log?.(`turn/cancel request ${args.requestId}`);
+    return { ok: true };
+  }
+  const turn = findTurnById(host.session, args.turnId) ?? host.loadTurn?.(args.turnId);
+  if (turn instanceof SessionTurn) {
+    requestTurnCancel(turn, turn.evalSpec?.requestId, host.session.cancelledEvalRequests);
+    host.cancelOwned(turn);
+  }
+  host.log?.(`turn/cancel turn ${args.turnId}`);
+  return { ok: true };
+}
+
+export function rewindTurn(host: SessionCommandHost, turnId: string): RewindResult {
+  const live = host.session.head;
+  if (live == null) return { ok: false, reason: "no-head", invalid: true };
+  const loaded = host.loadTurn?.(turnId) ?? findTurnById(host.session, turnId);
+  if (!(loaded instanceof SessionTurn)) return { ok: false, reason: "unknown-id", invalid: true };
+  const ceiling = resolvedTip(live, host.session.tip);
+  if (!isRewindPin(loaded) && loaded !== ceiling) return { ok: false, reason: "not-a-pin", invalid: true };
+  if (!onTipChain(loaded, ceiling, live)) return { ok: false, reason: "off-chain", invalid: true };
+  const open = host.session.liveChain.filter((turn) => turn.inLoop);
+  host.session.rewindHead(loaded, ceiling);
+  for (const turn of open) {
+    requestTurnCancel(turn, turn.evalSpec?.requestId, host.session.cancelledEvalRequests);
+    host.cancelOwned(turn);
+  }
+  host.restorePluginState?.();
+  host.log?.(`turn/rewind ${turnId}`);
+  return { ok: true, turnId: loaded.uuid };
+}
+
+export function retryTurn(host: SessionCommandHost): { readonly ok: true } {
+  const turn = host.session.findRunningTurn();
+  if (turn != null) {
+    const live = reactChunks(turn)
+      .map((chunk) => tapeCompletion(chunk))
+      .filter((pew) => pew != null && pew.outcome == null);
+    const completion = live.at(-1);
+    if (completion != null) host.skipBackoff?.(completion);
+  }
+  host.log?.("turn/retry");
+  return { ok: true };
+}
+
+export function drainPromptQueue(host: SessionCommandHost): void {
+  if (host.closed) return;
+  if (host.session.findRunningTurn() != null) return;
+  const item = host.session.promptQueue[0];
+  if (item == null) return;
+  host.syncSkills?.();
+  const trimmed = item.text.trim();
+  if (!looksLikePath(trimmed) && trimmed.startsWith("/")) {
+    const token = (trimmed.split("\n")[0] ?? "").trim().split(/\s/)[0] ?? "";
+    const verb = token.startsWith("/") && token.length >= 2 ? token.slice(1) : null;
+    if (verb === "compact") {
+      host.session.promptQueue.shift();
+      mintCompactTurn(host, trimmed.slice(trimmed.indexOf("compact") + "compact".length).trim());
+      return;
+    }
+    if (verb === "rename") {
+      host.session.promptQueue.shift();
+      const rest = trimmed.slice(trimmed.indexOf("rename") + "rename".length).trim();
+      host.rename?.(rest === "--auto" ? "" : rest);
+      drainPromptQueue(host);
+      return;
+    }
+    const verbs = new Set<string>([...HOST_QUEUE_VERBS, ...host.queuedVerbs()]);
+    if (verb !== null && verbs.has(verb)) {
+      host.session.promptQueue.shift();
+      host.log?.(`queue reject host-verb ${item.text}`);
+      return;
+    }
+    if (verb !== null && !host.session.skills.some((skill) => skillMatchesVerb(skill, verb))) {
+      host.session.promptQueue.shift();
+      host.log?.(`queue reject unknown-command ${item.text}`);
+      return;
+    }
+  }
+  if ((host.session.kvs.connection ?? "").trim() === "") return;
+  host.session.promptQueue.shift();
+  mintUserTurn(host, asUserPrompt(trimmed));
+}

package/src/session/compact-actor.ts

@@ -0,0 +1,132 @@
+/**
+ * Compact cases of the turn loop. Calculations come from context; the
+ * Scheme compact is `applyCompact`.
+ */
+import type { PromptComplete } from "@inhuman.tools/env-capability-module-prompt";
+import {
+  CompactJob,
+  liveBackgroundJobs,
+  liveJobsCheckIn,
+  SessionRoot,
+  SessionTurn,
+} from "@inhuman.tools/harness-model";
+
+import { applyCompact } from "./compact-env.js";
+import { loadCompactProgram, type CompactProgram } from "./compact.js";
+import {
+  compactRejectReason,
+  historyBehind,
+  keepFloorsOfJob,
+  sliceCompactZones,
+  stampCompactInputs,
+  textOfCell,
+  Transcript,
+} from "../context/index.js";
+
+/** Human tape only. Not injected into the next model prompt. */
+const COMPACT_FAILED_NOTICE = "couldn't compact — try again later";
+
+export type CompactHost = {
+  readonly turn: SessionTurn;
+  readonly session: SessionRoot;
+  readonly compactKeepTurns: number;
+  readonly compactStrategy: string;
+  readonly kernelFsRoot: string;
+  readonly connectionId: string;
+  readonly model: string;
+  complete?: PromptComplete;
+  loadProgram?: (spec: string | undefined, kernelFsRoot: string) => CompactProgram;
+  log?: (message: string) => void;
+  fail?: (label: string, error: unknown) => void;
+};
+
+function compactRead(
+  configFloor: number,
+  kv: Readonly<Record<string, string>>,
+): {
+  readonly configFloor: number;
+  readonly kv: Readonly<Record<string, string>>;
+} {
+  return { configFloor: Math.max(configFloor, 1), kv };
+}
+
+function failCompact(job: CompactJob): void {
+  job.failed = true;
+  job.notice = COMPACT_FAILED_NOTICE;
+  job.standIn = "";
+  job.markComplete();
+}
+
+function loadStrategy(host: CompactHost): CompactProgram {
+  return (host.loadProgram ?? loadCompactProgram)(host.compactStrategy, host.kernelFsRoot);
+}
+
+/** Abort leaves the job open: an incomplete compact is not a cutoff, and its owner settles it. */
+export async function runCompactJob(job: CompactJob, host: CompactHost, signal?: AbortSignal): Promise<void> {
+  const rejected = compactRejectReason(host.turn);
+  if (rejected != null) {
+    host.log?.(`compact ${rejected}`);
+    job.markComplete();
+    return;
+  }
+  try {
+    const session = host.session;
+    const read = compactRead(host.compactKeepTurns, session.kvs);
+    const eat = Transcript.fromCells(historyBehind(host.turn, read));
+    const need = host.turn.contextNeed;
+    // The job's cut comes from the settings recorded on it (F8). An unstamped
+    // job is stamped here, on its first run, and keeps that reading for good.
+    if (job.keepTurns == null) stampCompactInputs(job, read.configFloor, session.kvs);
+    const floors = keepFloorsOfJob(job, need, { kv: session.kvs, configFloor: read.configFloor });
+    const zones = sliceCompactZones(eat, floors);
+    if (zones.prefix.cells.length === 0) {
+      host.log?.("compact keep-all");
+      job.markComplete();
+      return;
+    }
+    const focus = job.reason === "user" ? host.turn.prompt.trim() || need?.focus || "" : (need?.focus ?? "");
+    const strategy = loadStrategy(host);
+    if (strategy.failsafe != null) {
+      // Keep-first is a failsafe, not a strategy: it keeps one cell and drops the
+      // rest. Say so, or a broken install looks like a working compaction.
+      host.fail?.("compact failsafe", `no compaction program loaded (${strategy.failsafe}); using keep-first`);
+      host.log?.(`compact failsafe: ${strategy.failsafe}`);
+    }
+    const result = await applyCompact(strategy.source, zones.prefix, eat, {
+      reason: job.reason,
+      focus,
+      kv: session.kvs,
+      forced: job.reason === "user",
+      sourcePath: strategy.sourcePath,
+      job: host.turn,
+      complete: host.complete,
+      connectionId: host.connectionId === "" ? undefined : host.connectionId,
+      completionModel: host.model === "" ? undefined : host.model,
+      signal,
+    });
+    if (!result.ok) {
+      host.fail?.("compact strategy", result.reason);
+      failCompact(job);
+      return;
+    }
+    const jobs = liveJobsCheckIn(await liveBackgroundJobs(session.motionWork()));
+    const body = result.checkIn
+      .map((cell) => textOfCell(cell).trim())
+      .filter((line) => line !== "")
+      .join("\n\n");
+    const checkIn = [jobs, body].filter((line) => line !== "").join("\n\n");
+    if (checkIn === "") {
+      host.fail?.("compact strategy", "empty-check-in");
+      failCompact(job);
+      return;
+    }
+    job.standIn = checkIn;
+    job.failed = false;
+    job.notice = "";
+    job.markComplete();
+  } catch (error) {
+    if (signal?.aborted) return;
+    host.fail?.("compact strategy", error);
+    failCompact(job);
+  }
+}