import type { CommandContext, CommandResult } from '../types.js';
/** True when this invocation asked for protocol JSON output. */
export declare const orgJson: (ctx: CommandContext) => boolean;
/** Print one protocol JSON payload on stdout (compact — one line, NDJSON-safe
 *  for line-oriented callers) and return a success result. */
export declare const printOrgJson: (payload: Record<string, unknown>) => CommandResult;
/** Validate org config(s) against OrgDefSchema — the exact parse `org run`/`org serve`
 * perform — plus the structural invariants the runtime assumes but the schema can't
 * express (single root role, resolvable reports_to, unique ids, parseable schedule). */
export declare const validateAction: (ctx: CommandContext) => Promise<CommandResult>;
/** `org logs <name> [--run id] [--role r] [--filter-tool t] [--filter-role r] [--tools-only] [--audit-filter allow|deny] [--follow]` — formatted bus.jsonl tail. */
export declare const logsAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
/**
 * `org watch <name> <role> [--verbose] [--stats]` — live-tail one role's
 * assistant chat text.
 *
 * Every runner (Claude included — this isn't specific to the subprocess CLI
 * runners) funnels through session.ts's shared message loop, which emits
 * each assistant-text chunk onto the bus as a `chat` event. This command is
 * just `logsAction` pre-filtered to that event type + role and formatted as
 * a plain transcript instead of the full annotated event line — a friendlier
 * front door onto infrastructure that already exists and already covers
 * every runtime uniformly. For the fuller event stream (tool calls, audit
 * decisions) use `org logs <name> --role <role> --follow` directly.
 *
 * --verbose additionally interleaves that role's `status` events (session
 * start/end, restart/crash/backoff, state changes) into the transcript, so
 * a human watching sees WHY a role went quiet instead of just silence.
 * --stats prints a running token/cost line off that role's `usage` events
 * (emitted per turn by session.ts, same as --verbose: already-existing bus
 * data, no new instrumentation).
 */
export declare const watchAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
/** `org report <name> [--run id] [--all] [--by-role] [--format mermaid]` — summarize a run (or list run history). */
export declare const reportAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
/** `org questions <name> [--all]` — list pending (or all) ask_human questions. */
export declare const questionsAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
/** `org answer <name> <question-id> <answer...>` — answer a pending ask_human question.
 *  Delivers live via the hosting daemon's /api/answer-question when the org is running
 *  (broker lookup); otherwise records the answer and queues it for the next run. */
export declare const answerAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
/** `org inbox <name> --json '{"from":"orgA:role","subject":"...","body":"..."}' [--to role]`
 *  Inbound entrypoint for cross-org/remote delivery — orgrt/remote.ts's deliverRemote()
 *  shells out to exactly this command over SSH. Live path: POST to the hosting daemon's
 *  /api/xdeliver when the org is registered with the broker (mirrors cross-org.ts's
 *  deliverRemote). Offline path: spool into inbox.jsonl, which the daemon drains into
 *  the target role's mailbox on the org's next start (daemon.ts drainInbox) — the same
 *  semantics as a queued human answer. */
export declare const inboxAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
/** `org create <name> --template <t> [--goal g] [--schedule s]` — scaffold a config from a template. */
export declare const createAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
/** `org costs <name> [--run id]` — show per-role cost tracking from runtime.json */
export declare const costsAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
/** `org flow <name> [--run id]` — export org flow as Mermaid diagram */
export declare const flowAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
/** `org approve <org> <role> <action>` — approve a pending tool/action approval */
export declare const approveAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
/** `org deny <org> <role> <action>` — deny a pending tool/action approval */
export declare const denyAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
/** `org replay <org> <run-id>` — time-travel debugging: re-emit a past run's bus
 *  events into a fresh replay run for inspection. This is event-log replay only —
 *  it does not restart agent execution or restore live sessions. To actually
 *  resume an org's execution from where it left off, use `org run --resume`. */
export declare const replayAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
/** `org resume-from <org>` — resume live execution from the org's persisted
 *  checkpoint (runtime.json): restores mailbox queues, policy/token counters,
 *  and session state, subject to checkpoint TTL and checksum validation. Unlike
 *  `replay`, this restarts real agent execution via `startOrg(..., { resume: true })`. */
export declare const resumeFromAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
/** `org branch <org> <run-id> <branch-name>` — snapshot a run's event log for replay.
 *  This is NOT an executable what-if scenario: it copies bus.jsonl into a new
 *  run directory tagged with a `.branch-source` marker so it can be inspected
 *  or replayed later; it does not fork or re-run agent execution.
 *  Delegates to the shared, atomic (tmp+rename) implementation in checkpoint-ops.ts. */
export declare const branchAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
/** `org decisions <org> [--run id]` — show Rifft-style decision traces */
export declare const decisionsAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
export declare const gatesAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
export declare const gateResolveAction: (ctx: CommandContext, name: string, approved: boolean) => Promise<CommandResult>;
/** `org events <name> [--run id] [--follow] [--since <eventId|iso>] [--ndjson]`
 *  — live tail of a run's bus.jsonl as NDJSON, one BusEvent per line
 *  (protocol §7.3). This is the machine streaming surface; `org logs` stays
 *  the human one. NDJSON is the only output mode (--ndjson accepted for
 *  spec symmetry). */
export declare const eventsAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
//# sourceMappingURL=org-observe.d.ts.map