omp-conductor 0.15.11 → 0.15.13

package/src/orchestrator-tick.ts

@@ -71,6 +71,7 @@ import {
   releaseDriftDigestLine,
   releaseRefusal,
   releaseToolMatch,
+  sharedHostGuardDigestLine,
   type ReleaseDecision,
 } from "./release-policy.ts";
 import {
@@ -83,6 +84,7 @@ import {
   type FrictionSignal,
   type HeldNotice,
   type InterruptCategory,
+  type IntakeItem,
   type MaterialEvent,
   type ReportScopeChoice,
   type ReportingPolicy,
@@ -704,8 +706,12 @@ export { TELEGRAM_APPROVAL_TOOL };
  */
 export const TICK_APPROVAL_UNAVAILABLE_RULE =
   `The ${TELEGRAM_APPROVAL_TOOL} tool is NOT mounted on this tick, so the package floor's yes/no amendment approval cannot be asked here. ` +
-  `If you have an amendment to propose, deliver the question with \`omp-conductor message --text "QUESTION: <the question>"\` — it resolves this project's own Telegram chat and topic — and wait for your operator's reply on a later turn. ` +
-  `A returned telegram_ask answer proves an answer, not Telegram delivery. ` +
+  `If you have an amendment to propose, deliver the question with \`omp-conductor message --category decision-needed --text "<the question>"\` — ` +
+  `it resolves this project's own Telegram chat and topic, records the question as an open decision row, and applies the ` +
+  `same availability policy as the tick: an unanswered yes/no stays pending — re-surfaced in every tick until answered ` +
+  `or the seven-day expiry, never recorded as approved. ` +
+  `Wait for the operator's reply on a later turn, then resolve the row with \`omp-conductor decision resolve <id> --answer "..."\`. ` +
+  `A returned answer proves an answer, not Telegram delivery. ` +
   `Never apply an amendment, or record one as approved, without an explicit answer you actually received.`;
 
 /**
@@ -725,6 +731,32 @@ export const TICK_ASK_RULE =
   `The ${TELEGRAM_APPROVAL_TOOL} tool is refused here: it would wait for your operator for as long as the answer ` +
   `takes, and an unanswered question must never hold the loop.`;
 
+/**
+ * What a tick says when the bounded ask surface did not actually mount on this
+ * session (#520). {@link TICK_ASK_RULE} is appended only to a tick whose live
+ * mounted set carries {@link ASK_TOOL}; this is the other half of that
+ * agreement, and it has to carry the ask's semantics rather than just its text:
+ * the escalation category is declared from the vocabulary that already exists
+ * (the `conductor_ask` category is the same one), and the fallback command
+ * records the question as an open decision row, so "nobody answered" is a
+ * durable pending row re-surfaced in every tick — never "asked once, no reply,
+ * dropped". It also names the #524 consequence of a plain send: delivery
+ * follows the fleet's reporting policy, so a category the policy defers waits
+ * for the scheduled digest, and a *blocking* question must declare a category
+ * the fleet interrupts on.
+ */
+export const TICK_ASK_UNAVAILABLE_RULE =
+  `The ${ASK_TOOL} tool is NOT mounted on this tick, so the bounded ask surface is unavailable on this session. ` +
+  `Ask through the CLI fallback instead: run \`omp-conductor message --category <category> --text "<the question>"\` ` +
+  `with the escalation category declared from the policy vocabulary — fleet-stopped, tier2 or decision-needed — ` +
+  `never smuggled through a "QUESTION:" text prefix. The command records the question as an open decision row before ` +
+  `delivering, parked on silence: nobody answering keeps the row open and pending, re-surfaced in every tick until ` +
+  `answered or the seven-day expiry, never an approval. Delivery follows the same reporting policy as the tick — a ` +
+  `category the fleet's interruptOn list defers waits for the next digest or working-hours catch-up and prints a ` +
+  `held-notice id, so a blocking question must declare a category the fleet interrupts on (tier2 or fleet-stopped). ` +
+  `Wait for the operator's reply on a later turn, then resolve the row with \`omp-conductor decision resolve <id> --answer "..."\`. ` +
+  `A returned answer proves an answer, not Telegram delivery.`;
+
 /**
  * The gate's refusal for a raw {@link TELEGRAM_APPROVAL_TOOL} / `write
  * xd://telegram_ask` call on a locally injected tick (#438). Fixed wording the
@@ -798,6 +830,49 @@ export function formatFrictionDigest(signals: readonly FrictionSignal[]): string
   return lines.join("\n");
 }
 
+/** Bounds one pending idea's text in the tick prompt, like the digest ledger. */
+const INTAKE_TEXT_LIMIT = 160;
+
+/**
+ * Pending intake items, each waiting to become an issue (#300).
+ *
+ * The one appended block that is a *duty* rather than a read-out: every pending
+ * item is listed with its id and text (oldest first, as the store returns
+ * them), followed by the standing instruction for grooming one into an issue —
+ * file it without the queue label, mark provenance with `intake groomed`, and
+ * name the grooming in the digest ledger. Absent when nothing is pending: an
+ * empty intake is the common state of a healthy fleet, and a block that said
+ * "0 pending" every tick would be permanent noise — the same convention as
+ * {@link queueDigestLine}. Project-specific grooming taste (priority scales,
+ * template wording) stays in POLICY.md; this block carries only the floor duty.
+ */
+export function formatPendingIntake(
+  items: readonly IntakeItem[],
+  instruction: { tracker: string; queueLabel: string; labelPrefix: string },
+): string | undefined {
+  if (items.length === 0) return undefined;
+  const oneLine = (text: string): string => {
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length <= INTAKE_TEXT_LIMIT ? flat : `${flat.slice(0, INTAKE_TEXT_LIMIT - 1)}…`;
+  };
+  const lines = [
+    `Pending intake — ${items.length} idea(s) captured, waiting to be groomed into issues, oldest first:`,
+    ...items.map((item) => `- ${item.id} — ${oneLine(item.text)}`),
+    "",
+    `Groom each into exactly one issue on ${instruction.tracker}: a title stating the problem; a body ` +
+      `carrying the product rationale and the acceptance criteria as a checklist; the routing ` +
+      `"${instruction.labelPrefix}<repo>" label and a priority per POLICY.md. File it WITHOUT the ` +
+      `"${instruction.queueLabel}" queue label — filing is not promoting, and never add ` +
+      `${instruction.queueLabel} to an issue you groomed from intake. Then mark provenance with ` +
+      "`omp-conductor intake groomed <id> --issue <url>` — an already-groomed id is a no-op, and an " +
+      "idea is filed exactly once — and record the outcome with `omp-conductor event record --category " +
+      'intake --summary "groomed intake <id> → #<issue-number>" --evidence <url>` so the digest names ' +
+      "the grooming. An item that is malformed or empty is dismissed with `omp-conductor intake dismiss " +
+      "<id>` and noted in the digest rather than filed.",
+  ];
+  return lines.join("\n");
+}
+
 /**
  * The scope this tick carries, where the brief actually lives, and — when the
  * config could not answer — why.
@@ -2258,7 +2333,13 @@ function tick(pi: TickApi, ctx: TickContext, config: TickConfig, session: TickSe
     // tick — it would wait unbounded — so the tick names the replacement
     // surface up front, custom message included.
     content = `${content}\n${availabilityPrompt(scope.policy, Date.now())}`;
-    content = `${content}\n${TICK_ASK_RULE}`;
+    // The ask rule names the surface this session can actually call (#520):
+    // the bounded ask is registered at `session_start`, so the live mounted
+    // set read here — between turns, in the heartbeat timer — is the honest
+    // source for whether the registration took. A tick that mandates a tool
+    // the session does not carry is #114 all over again, so a missing surface
+    // degrades to the CLI path that exists and carries the ask's semantics.
+    content = `${content}\n${pi.getActiveTools().includes(ASK_TOOL) ? TICK_ASK_RULE : TICK_ASK_UNAVAILABLE_RULE}`;
   }
   let frictionStore: Store | undefined;
   let frictionSignals: FrictionSignal[] = [];
@@ -2266,6 +2347,12 @@ function tick(pi: TickApi, ctx: TickContext, config: TickConfig, session: TickSe
   if (scope.projectName !== undefined) {
     const drift = releaseDriftDigestLine(scope.projectName);
     if (drift !== undefined) content = `${content}\n${drift}`;
+    // The shared-host gate's refusals are reported on their own line, apart
+    // from release drift (#562): a worker being stopped by the interlock is
+    // the guard working, never a release-policy divergence, and it must not
+    // move the drift counter or borrow the release-policy heading.
+    const guard = sharedHostGuardDigestLine(scope.projectName);
+    if (guard !== undefined) content = `${content}\n${guard}`;
     if (existsSync(dbPath())) {
       try {
         frictionStore = openStore(dbPath());
@@ -2304,8 +2391,17 @@ function tick(pi: TickApi, ctx: TickContext, config: TickConfig, session: TickSe
             project.groomBelow ?? DEFAULT_GROOM_BELOW,
           );
           if (queue !== undefined) content = `${content}\n${queue}`;
+          // Pending intake is the same class of standing block as the friction
+          // and decisions read-outs: a store-backed duty the orchestrator must
+          // not derive from memory. The store answers, the prompt instructs.
+          const pendingIntake = formatPendingIntake(frictionStore.pendingIntake(scope.projectName), {
+            tracker: project.tracker.repo,
+            queueLabel: project.queueLabel,
+            labelPrefix: project.routing.labelPrefix,
+          });
+          if (pendingIntake !== undefined) content = `${content}\n${pendingIntake}`;
         } catch {
-          // unreadable config: no queue digest this tick
+          // unreadable config: no queue digest or pending-intake block this tick
         }
       } catch (err) {
         frictionStore?.close();
@@ -2749,7 +2845,6 @@ export default function orchestratorTickExtension(pi: TickApi): void {
    */
   const armAskTool = (config: TickConfig, configuredProject: string | undefined): void => {
     if (askToolArmed) return;
-    askToolArmed = true;
     pi.registerTool({
       name: ASK_TOOL,
       label: ASK_TOOL,
@@ -2834,6 +2929,14 @@ export default function orchestratorTickExtension(pi: TickApi): void {
         return { content: [{ type: "text", text: result.text }] };
       },
     });
+    // Latched after the registration returns, not before: a throw inside
+    // `registerTool` must not leave the surface permanently unmounted — the
+    // latch would otherwise turn a transient registration failure into a
+    // missing ask surface for the whole session (#520). On a real harness
+    // `session_start` fires once, so this is a retry on the next session
+    // rather than a loop, but it is the difference between a recovery and a
+    // permanent divergence between the prompt and the mounted set.
+    askToolArmed = true;
   };
 
   pi.on("session_start", (_event, ctx) => {

package/src/orchestrator.ts

@@ -33,8 +33,8 @@ import { stateDir } from "./config.ts";
 import { formatEscalation } from "./escalate.ts";
 import { createSession, disposeSession } from "./omp.ts";
 import type { AgentSessionLike } from "./omp.ts";
-import type { ReleaseBlockContext } from "./release-policy.ts";
-import type { Escalation, ReleaseShape, ResolvedGrants, SessionRole } from "./types.ts";
+import type { GateShape, ReleaseBlockContext } from "./release-policy.ts";
+import type { Escalation, ResolvedGrants, SessionRole } from "./types.ts";
 
 /**
  * The session factory {@link startOrchestrator} uses. Named so the test seam
@@ -47,7 +47,7 @@ export type CreateSessionFn = (opts: {
   resume?: boolean;
   role: SessionRole;
   releaseGrants?: ResolvedGrants;
-  onReleaseBlocked?: (shape: ReleaseShape, context: ReleaseBlockContext) => void;
+  onReleaseBlocked?: (shape: GateShape, context: ReleaseBlockContext) => void;
   onSpawn?: (pid: number) => void;
   socketPath?: string;
   verbSocketPath?: string;
@@ -76,6 +76,11 @@ export interface OrchestratorHandle {
    */
   deliver(e: Escalation, project: string): Promise<DeliveryReceipt>;
   busy(): boolean;
+  /** Whether the underlying session is still running. Event-driven, never a
+   *  timer: set false by the proxy's real `session_exit` terminal event, and
+   *  false once the handle has been disposed. A wedged-but-alive session still
+   *  reads alive here — that is the stall watchdog's job, not liveness. */
+  alive(): boolean;
   sessionFile(): string | undefined;
   dispose(): Promise<void>;
 }
@@ -85,7 +90,7 @@ export interface OrchestratorOpts {
   sessionDir?: string;
   model?: string;
   releaseGrants?: ResolvedGrants;
-  onReleaseBlocked?: (shape: ReleaseShape, context: ReleaseBlockContext) => void;
+  onReleaseBlocked?: (shape: GateShape, context: ReleaseBlockContext) => void;
   /** The child's pid, the instant it exists. See {@link VerbListener.bindPid}. */
   onSpawn?: (pid: number) => void;
   /** Control socket for the session child, beside its own working directory. */
@@ -216,6 +221,14 @@ export async function startOrchestrator(o: OrchestratorOpts): Promise<Orchestrat
   });
 
   let disposed = false;
+  // Read by the handle's `alive()`: a session that has ended is gone whether
+  // it crashed or was shut down, and from that instant nothing about it can be
+  // relied on. Driven by the proxy's `session_exit` terminal event — a real
+  // signal, not a timer, and not the `agent_end`/streaming bookkeeping above.
+  let terminated = false;
+  session.on("session_exit", () => {
+    terminated = true;
+  });
   /** Tail of the delivery queue. Always settled-or-settling, never rejected. */
   let queue: Promise<void> = Promise.resolve();
   /** Consumed by the first injection; see {@link OrchestratorOpts.brief}. */
@@ -273,6 +286,7 @@ export async function startOrchestrator(o: OrchestratorOpts): Promise<Orchestrat
       return accepted;
     },
     busy: () => streaming,
+    alive: () => !terminated && !disposed,
     // The path the harness actually opened, read live: the transcript is how a
     // human audits what the orchestrator decided on their behalf.
     sessionFile: () => session.sessionFile,

package/src/privileged.ts

@@ -90,6 +90,14 @@ export interface RunPrivilegedOptions {
   title?: string;
   /** Extra lines shown above the step list — what this batch is for. */
   preamble?: readonly string[];
+  /**
+   * Runs after the confirm and the sudo priming, immediately before the first
+   * step. A caller that must do something between consent and execution — the
+   * pause/drain of a draining restart — does it here, under the same confirm,
+   * so the operator authorises the whole batch at once. A throw propagates to
+   * the caller with nothing restarted.
+   */
+  beforeRun?: () => Promise<void>;
 }
 
 /**
@@ -211,6 +219,8 @@ export async function runPrivileged(
     }
   }
 
+  await options.beforeRun?.();
+
   const softFailures: { step: PrivilegedStep; stderr: string }[] = [];
   for (const [index, step] of steps.entries()) {
     ui.notify(`[${index + 1}/${steps.length}] ${step.title}`, "info");