dsh-tower 2.0.4 → 2.1.0-beta.1

package/domain/contracts/outputs.js

@@ -0,0 +1,279 @@
+// Tool schema primitives and output schemas.
+
+const S = {
+  str: { type: 'string' },
+  int: { type: 'integer' },
+  bool: { type: 'boolean' },
+  arr: (items) => ({ type: 'array', items }),
+  obj: (properties = {}, required = []) => ({ type: 'object', properties, required, additionalProperties: true }),
+  any: {},
+}
+
+const blockerSchema = S.obj({ code: S.str, detail: S.str, cleanup: S.str, timeout: S.bool }, ['code', 'detail'])
+const worktreeSchema = S.obj({ path: S.str, branch: S.str, baseCommit: S.str })
+const missionSummarySchema = S.obj({
+  id: S.str,
+  title: S.str,
+  kind: S.str,
+  status: S.str,
+  scope: S.arr(S.str),
+  deps: S.arr(S.str),
+  owner: S.any,
+  worktree: S.any,
+  blockers: S.arr(S.str),
+  tasks: S.any,
+  scopeGeneration: S.int,
+  mergedCommit: S.any,
+  mergedAt: S.any,
+  updatedAt: S.any,
+})
+const findingSummarySchema = S.obj({
+  id: S.str,
+  seq: S.int,
+  type: S.str,
+  title: S.str,
+  severity: S.any,
+  status: S.str,
+  missionId: S.any,
+  branch: S.any,
+  reportedBy: S.any,
+  at: S.any,
+  updatedAt: S.any,
+  closedAt: S.any,
+})
+
+// Per-tool output schemas. `additionalProperties: true` keeps future fields
+// additive; `required` lists only fields every successful path returns.
+const SCHEMAS = {
+  init: S.obj(
+    {
+      created: S.bool,
+      repoRoot: S.str,
+      commonDir: S.str,
+      statePath: S.str,
+      base: S.str,
+      revision: S.int,
+      missions: S.int,
+    },
+    ['created', 'repoRoot', 'commonDir', 'statePath', 'base', 'revision', 'missions'],
+  ),
+  plan: S.obj({ revision: S.int, missions: S.arr(missionSummarySchema) }, ['revision', 'missions']),
+  mission: S.obj({ revision: S.int, mission: S.obj() }, ['revision', 'mission']),
+  status: S.obj(
+    {
+      repoRoot: S.str,
+      commonDir: S.str,
+      statePath: S.str,
+      base: S.str,
+      revision: S.int,
+      counts: S.obj(),
+      openTasks: S.int,
+      roster: S.int,
+      messages: S.int,
+      unreadTower: S.int,
+      findings: S.int,
+      findingsByStatus: S.obj(),
+      reviews: S.int,
+      config: S.obj({ path: S.any, repoConfigPresent: S.bool, spawn: S.obj() }),
+      recentFindings: S.arr(S.obj()),
+      missions: S.arr(S.obj()),
+      activity: S.arr(S.obj()),
+      mode: S.any,
+      spawn: S.any,
+      towerAgentId: S.any,
+      ownerMissing: S.bool,
+    },
+    ['repoRoot', 'commonDir', 'statePath', 'base', 'revision', 'counts', 'missions', 'activity'],
+  ),
+  spawn: S.obj(
+    {
+      name: S.str,
+      agentId: S.str,
+      role: S.str,
+      missionId: S.str,
+      preset: S.str,
+      provider: S.str,
+      maxDepth: S.int,
+      agentOptions: S.any,
+      worktree: worktreeSchema,
+      created: S.bool,
+      briefingChars: S.int,
+      rosterEntry: S.obj(),
+      stopReason: S.any,
+      timedOut: S.bool,
+      output: S.any,
+      diagnostic: S.any,
+    },
+    ['name', 'agentId', 'role', 'missionId', 'preset', 'provider', 'worktree'],
+  ),
+  roster: S.obj(
+    { revision: S.int, roster: S.arr(S.obj()), parentStatus: S.obj(), missions: S.arr(S.obj()) },
+    ['revision', 'roster', 'parentStatus', 'missions'],
+  ),
+  diff: S.obj(
+    {
+      missionId: S.str,
+      branch: S.str,
+      baseTip: S.str,
+      branchTip: S.str,
+      mergeBase: S.str,
+      files: S.arr(S.str),
+      commits: S.arr(S.str),
+      truncated: S.bool,
+      patch: S.str,
+    },
+    ['missionId', 'branch', 'baseTip', 'branchTip', 'mergeBase', 'files', 'commits', 'truncated', 'patch'],
+  ),
+  adopt: S.obj(
+    { retired: S.arr(S.str), skippedUnknownParents: S.arr(S.str), roster: S.arr(S.obj()), parentStatus: S.obj() },
+    ['retired', 'skippedUnknownParents', 'roster', 'parentStatus'],
+  ),
+  send: S.obj({ message: S.obj(), deliveries: S.arr(S.obj()) }, ['message', 'deliveries']),
+  inbox: S.obj(
+    { reader: S.str, messages: S.arr(S.obj()), pageSize: S.int, unreadRemaining: S.int },
+    ['reader', 'messages', 'pageSize', 'unreadRemaining'],
+  ),
+  complete: S.obj({ mission: S.obj(), commits: S.int, unread: S.int }, ['mission', 'commits', 'unread']),
+  finding: S.obj(
+    {
+      id: S.str,
+      seq: S.int,
+      type: S.str,
+      title: S.str,
+      severity: S.any,
+      summary: S.str,
+      location: S.any,
+      details: S.str,
+      suggested_fix: S.str,
+      missionId: S.any,
+      branch: S.any,
+      reportedBy: S.any,
+      at: S.any,
+      status: S.str,
+      updatedAt: S.any,
+      closedAt: S.any,
+      notes: S.arr(S.obj()),
+    },
+    ['id', 'type', 'title', 'summary', 'details', 'suggested_fix', 'status'],
+  ),
+  findings: S.obj(
+    {
+      findings: S.arr(findingSummarySchema),
+      finding: S.obj(),
+      counts: S.obj(),
+      total: S.int,
+      filtered: S.int,
+      action: S.str,
+    },
+    ['counts', 'total'],
+  ),
+  review: S.obj(
+    { review: S.obj(), branchTip: S.str, missionStatus: S.str, round: S.int, reviewerRounds: S.int },
+    ['review', 'branchTip', 'missionStatus', 'round', 'reviewerRounds'],
+  ),
+  preflight: S.obj(
+    {
+      ok: S.bool,
+      blockers: S.arr(blockerSchema),
+      missionId: S.str,
+      branchTip: S.any,
+      baseTip: S.any,
+      changedFiles: S.any,
+      review: S.any,
+    },
+    ['ok', 'blockers', 'missionId'],
+  ),
+  merge: S.obj(
+    {
+      ok: S.bool,
+      missionId: S.str,
+      mergedCommit: S.any,
+      baseTip: S.any,
+      branchTip: S.any,
+      parents: S.any,
+      blockers: S.arr(blockerSchema),
+      warnings: S.any,
+      alreadyMerged: S.bool,
+      recoveredFromFailure: S.bool,
+    },
+    ['ok'],
+  ),
+  rebase: S.obj(
+    {
+      ok: S.bool,
+      oldTip: S.any,
+      newTip: S.any,
+      baseTip: S.any,
+      alreadyMerged: S.bool,
+      alreadyUpToDate: S.bool,
+      skipped: S.bool,
+      reviewWaived: S.bool,
+      note: S.str,
+      blockers: S.arr(blockerSchema),
+    },
+    ['ok'],
+  ),
+  teardown: S.obj(
+    { ok: S.bool, dryRun: S.bool, removed: S.arr(S.str), decisions: S.arr(S.obj()) },
+    ['ok', 'dryRun', 'removed', 'decisions'],
+  ),
+  interrupt: S.obj(
+    {
+      ok: S.bool,
+      interrupted: S.bool,
+      previousActivity: S.str,
+      entry: S.obj(),
+      reason: S.str,
+    },
+    ['ok', 'interrupted'],
+  ),
+  reload: S.obj(
+    {
+      ok: S.bool,
+      scheduled: S.bool,
+      delayMs: S.int,
+      requiredIds: S.arr(S.str),
+      error: S.str,
+      restartHint: S.str,
+    },
+    ['ok', 'scheduled'],
+  ),
+  doctor: S.obj({ ok: S.bool, checks: S.arr(S.obj()), environmentContract: S.obj() }, ['ok', 'checks']),
+  recover: S.obj(
+    { ok: S.bool, action: S.str, stateLock: S.any, cleared: S.bool, backup: S.any, error: S.str },
+    ['ok', 'action'],
+  ),
+  test: S.obj(
+    {
+      ok: S.bool,
+      configured: S.bool,
+      treeTip: S.any,
+      tests: S.arr(S.obj()),
+      commands: S.arr(S.obj()),
+      error: S.str,
+      receipt: S.obj(),
+      checks: S.arr(S.obj()),
+    },
+    ['ok', 'configured'],
+  ),
+  batch: S.obj(
+    { ok: S.bool, action: S.str, batch: S.obj(), batches: S.arr(S.obj()), blockers: S.arr(blockerSchema), summary: S.obj() },
+    ['ok', 'action'],
+  ),
+  resource: S.obj(
+    { ok: S.bool, action: S.str, lease: S.obj(), leases: S.arr(S.obj()), released: S.bool },
+    ['ok', 'action'],
+  ),
+  importLegacy: S.obj({ ok: S.bool, summary: S.obj(), snapshot: S.obj() }, ['ok', 'summary']),
+  legacyMap: S.obj({ ok: S.bool, map: S.obj(), maps: S.arr(S.obj()) }, ['ok']),
+}
+
+function renderValue(_args, value) {
+  return [{ type: 'text', text: JSON.stringify(value, null, 2) }]
+}
+
+function output(schema) {
+  return { schema, render: renderValue }
+}
+
+export { S, SCHEMAS, output }

package/domain/contracts/tool-inputs/collaboration.js

@@ -0,0 +1,58 @@
+// tower_spawn / tower_roster / tower_interrupt / tower_send / tower_inbox /
+// tower_adopt input contracts. Pure TypeBox only; no I/O.
+import { ROLES } from '../../vocabulary.js'
+import { Type, enumOf } from './shared.js'
+
+export const SpawnInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  missionId: Type.Optional(Type.String({ description: 'Mission id, e.g. M1 (canonical; alias: id).' })),
+  id: Type.Optional(Type.String({ description: 'Alias for missionId; both are accepted.' })),
+  role: Type.Optional(enumOf(ROLES, { description: 'worker executes; reviewer audits the mission branch.' })),
+  name: Type.Optional(Type.String({ description: 'Unique roster name; defaults to <role>-<missionId>.' })),
+  instructions: Type.Optional(Type.String({ description: 'Extra tower instructions appended to the briefing.' })),
+  worktreeRoot: Type.Optional(Type.String({ description: 'Optional absolute parent directory for the worktree.' })),
+  wait: Type.Optional(Type.Boolean({ description: 'Wait for the child result instead of returning immediately (testing/debug).' })),
+  waitMs: Type.Optional(Type.Number({ description: 'Max wait with wait=true, default 180000; clamped to spawn.maxWaitMs (default 90000).' })),
+  wait_ms: Type.Optional(Type.Number({ description: 'Alias for waitMs.' })),
+  takeover: Type.Optional(Type.Boolean({ description: 'Replace a live worker entry that is no longer running (increments ownerGeneration).' })),
+  includeDirtyBase: Type.Optional(Type.Boolean({ description: 'Use the recorded snapshotCommit baseline when true (default true).' })),
+}, { additionalProperties: false })
+
+export const RosterInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+}, { additionalProperties: false })
+
+export const InterruptInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  to: Type.Optional(Type.String({ description: 'Roster name to interrupt.' })),
+  agentId: Type.Optional(Type.String({ description: 'Agent/session id to interrupt (alternative to to).' })),
+  agent_id: Type.Optional(Type.String({ description: 'Alias for agentId.' })),
+  reason: Type.Optional(Type.String({ description: 'Why the agent is being interrupted (recorded in the roster).' })),
+}, { additionalProperties: false })
+
+export const SendInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  to: Type.String({ description: 'Recipient: a roster agent name, "tower", or "all".' }),
+  subject: Type.String({ description: 'One-line subject.' }),
+  body: Type.String({ description: 'Full message body (markdown).' }),
+  scope: Type.Optional(Type.String({ description: 'Optional scope tag, e.g. the mission id.' })),
+  interrupt: Type.Optional(
+    Type.Boolean({
+      description: 'Interrupt the recipient\'s current turn before delivering (Kimi-style "message interrupts the running turn"); default false = queue at the next step boundary.',
+    }),
+  ),
+  consentRef: Type.Optional(Type.String({ description: 'Optional audit reference recording who consented to this instruction.' })),
+  consent_ref: Type.Optional(Type.String({ description: 'Alias for consentRef.' })),
+}, { additionalProperties: false })
+
+export const InboxInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  limit: Type.Optional(Type.Number({ description: 'Max messages to return (default 20), newest first.' })),
+  include_read: Type.Optional(Type.Boolean({ description: 'Include previously acknowledged messages for history lookup.' })),
+  includeRead: Type.Optional(Type.Boolean({ description: 'Alias for include_read.' })),
+}, { additionalProperties: false })
+
+export const AdoptInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  retireMissing: Type.Optional(Type.Boolean({ description: 'Retire provably gone agents (default true); false marks them missing instead.' })),
+}, { additionalProperties: false })

package/domain/contracts/tool-inputs/findings.js

@@ -0,0 +1,29 @@
+// tower_finding / tower_findings input contracts. Pure TypeBox only; no I/O.
+import { FINDING_FILTER_STATUSES, FINDING_SEVERITIES, FINDING_TYPES } from '../../vocabulary.js'
+import { Type, enumOf } from './shared.js'
+
+export const FindingInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  type: enumOf(FINDING_TYPES, { description: 'Finding category.' }),
+  title: Type.String({ description: 'Short finding title.' }),
+  severity: Type.Optional(enumOf(FINDING_SEVERITIES, { description: 'Optional severity.' })),
+  summary: Type.String({ description: 'What was found, in a sentence or two.' }),
+  location: Type.Optional(Type.String({ description: 'File/symbol the finding concerns.' })),
+  details: Type.String({ description: 'Full details: evidence, reproduction, impact.' }),
+  suggested_fix: Type.String({ description: 'What you would do about it.' }),
+  missionId: Type.Optional(Type.String({ description: 'Optional mission this finding relates to (alias: mission_id).' })),
+  mission_id: Type.Optional(Type.String({ description: 'Alias for missionId.' })),
+}, { additionalProperties: false })
+
+export const FindingsInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  id: Type.Optional(Type.String({ description: 'Finding id, e.g. F1. When present the call reads or updates that finding.' })),
+  status: Type.Optional(enumOf(FINDING_FILTER_STATUSES, { description: 'With id: target status. Without id: filter (default all).' })),
+  note: Type.Optional(Type.String({ description: 'Optional note recorded together with an update.' })),
+  type: Type.Optional(enumOf(FINDING_TYPES, { description: 'Filter by finding type.' })),
+  severity: Type.Optional(enumOf(FINDING_SEVERITIES, { description: 'Filter by severity.' })),
+  missionId: Type.Optional(Type.String({ description: 'Filter by mission id (alias: mission_id).' })),
+  mission_id: Type.Optional(Type.String({ description: 'Alias for missionId.' })),
+  open: Type.Optional(Type.Boolean({ description: 'Only findings that are not fixed or wontfix.' })),
+  limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 200, description: 'Max findings to list (default 50).' })),
+}, { additionalProperties: false })

package/domain/contracts/tool-inputs/index.js

@@ -0,0 +1,94 @@
+// Tool input contracts (#56 P3c): named schemas grouped by area plus a
+// `ToolInputs` map keyed by registered tool name. Pure data; no I/O.
+import {
+  CompleteInput,
+  MissionInput,
+  PlanInput,
+  PreflightInput,
+  ReviewInput,
+  StatusInput,
+} from './missions.js'
+import {
+  AdoptInput,
+  InboxInput,
+  InterruptInput,
+  RosterInput,
+  SendInput,
+  SpawnInput,
+} from './collaboration.js'
+import { DiffInput, MergeInput, RebaseInput, TeardownInput } from './integration.js'
+import { FindingInput, FindingsInput } from './findings.js'
+import {
+  BatchInput,
+  DoctorInput,
+  ImportLegacyInput,
+  InitInput,
+  LegacyMapInput,
+  RecoverInput,
+  ReloadInput,
+  ResourceInput,
+  TestInput,
+} from './ops.js'
+
+export {
+  CompleteInput,
+  MissionInput,
+  PlanInput,
+  PreflightInput,
+  ReviewInput,
+  StatusInput,
+  AdoptInput,
+  InboxInput,
+  InterruptInput,
+  RosterInput,
+  SendInput,
+  SpawnInput,
+  DiffInput,
+  MergeInput,
+  RebaseInput,
+  TeardownInput,
+  FindingInput,
+  FindingsInput,
+  BatchInput,
+  DoctorInput,
+  ImportLegacyInput,
+  InitInput,
+  LegacyMapInput,
+  RecoverInput,
+  ReloadInput,
+  ResourceInput,
+  TestInput,
+}
+
+/** @type {Record<string, import('@sinclair/typebox').TSchema>} */
+const ToolInputs = {
+  tower_init: InitInput,
+  tower_plan: PlanInput,
+  tower_mission: MissionInput,
+  tower_status: StatusInput,
+  tower_spawn: SpawnInput,
+  tower_roster: RosterInput,
+  tower_interrupt: InterruptInput,
+  tower_adopt: AdoptInput,
+  tower_send: SendInput,
+  tower_inbox: InboxInput,
+  tower_complete: CompleteInput,
+  tower_finding: FindingInput,
+  tower_findings: FindingsInput,
+  tower_diff: DiffInput,
+  tower_review: ReviewInput,
+  tower_preflight: PreflightInput,
+  tower_merge: MergeInput,
+  tower_rebase: RebaseInput,
+  tower_teardown: TeardownInput,
+  tower_doctor: DoctorInput,
+  tower_recover: RecoverInput,
+  tower_test: TestInput,
+  tower_batch: BatchInput,
+  tower_resource: ResourceInput,
+  tower_import_legacy: ImportLegacyInput,
+  tower_legacy_map: LegacyMapInput,
+  tower_reload: ReloadInput,
+}
+
+export { ToolInputs }

package/domain/contracts/tool-inputs/integration.js

@@ -0,0 +1,37 @@
+// tower_merge / tower_rebase / tower_teardown / tower_diff input contracts.
+// Pure TypeBox only; no I/O.
+import { Type } from './shared.js'
+
+export const MergeInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  missionId: Type.Optional(Type.String({ description: 'Mission id, e.g. M1 (canonical; alias: id).' })),
+  id: Type.Optional(Type.String({ description: 'Alias for missionId; both are accepted.' })),
+  timeoutMs: Type.Optional(
+    Type.Integer({
+      minimum: 1000,
+      description: 'Optional timeout for the merge command in milliseconds, including pre-merge hooks (default 15 minutes).',
+    }),
+  ),
+  timeout_ms: Type.Optional(Type.Integer({ minimum: 1000, description: 'Alias for timeoutMs.' })),
+}, { additionalProperties: false })
+
+export const RebaseInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  missionId: Type.Optional(Type.String({ description: 'Mission id, e.g. M1 (canonical; alias: id).' })),
+  id: Type.Optional(Type.String({ description: 'Alias for missionId; both are accepted.' })),
+}, { additionalProperties: false })
+
+export const TeardownInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  force: Type.Optional(Type.Boolean({ description: 'Remove worktrees that contain uncommitted changes (never a live agent).' })),
+  exclude: Type.Optional(Type.Array(Type.String(), { description: 'Mission ids to keep.' })),
+  dry_run: Type.Optional(Type.Boolean({ description: 'Preview remove/keep decisions without changing disk or state.' })),
+  dryRun: Type.Optional(Type.Boolean({ description: 'Alias for dry_run.' })),
+}, { additionalProperties: false })
+
+export const DiffInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path to the main checkout root.' }),
+  missionId: Type.Optional(Type.String({ description: 'Mission id, e.g. M1 (canonical; alias: id).' })),
+  id: Type.Optional(Type.String({ description: 'Alias for missionId; both are accepted.' })),
+  maxBytes: Type.Optional(Type.Integer({ minimum: 1024, description: 'Patch cap in bytes (default 65536).' })),
+}, { additionalProperties: false })

package/domain/contracts/tool-inputs/missions.js

@@ -0,0 +1,94 @@
+// tower_plan / tower_mission / tower_status / tower_complete / tower_review /
+// tower_preflight input contracts. Pure TypeBox only; no I/O.
+import {
+  MERGE_VERDICTS,
+  MISSION_KINDS,
+  MISSION_STATUSES,
+  PAUSE_CAUSES,
+  REVIEW_POLICIES,
+  STATUS_FORMATS,
+} from '../../vocabulary.js'
+import { Type, enumOf } from './shared.js'
+
+export const PlanInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  missions: Type.Array(
+    Type.Object({
+      title: Type.String({ description: 'Printable ASCII title; used as the mission label.' }),
+      scope: Type.Optional(Type.Array(Type.String(), { description: 'Relative file globs this mission may touch; empty only for survey.' })),
+      tasks: Type.Optional(Type.Array(Type.String(), { description: 'Verifiable task items the worker ticks off.' })),
+      deps: Type.Optional(Type.Array(Type.String(), { description: 'Mission ids that must merge before this one.' })),
+      kind: Type.Optional(enumOf(MISSION_KINDS, { description: 'survey = read-only investigation that reserves no scope.' })),
+      context: Type.Optional(Type.String({ description: "The user's own key sentences, verbatim (max 4096 chars)." })),
+      references: Type.Optional(Type.Array(Type.String(), { maxItems: 20, description: 'Read-only pointers/files the worker should read (max 20); copied into the briefing.' })),
+      reviewPolicy: Type.Optional(enumOf(REVIEW_POLICIES, { description: 'required-clean (mission default) means a clean review is required when review.requireReview is on; none needs reviewExemptionReason, and with the review gate on it also needs gates.allowReviewExemption.' })),
+      reviewExemptionReason: Type.Optional(Type.String({ description: 'Non-empty justification when reviewPolicy is "none".' })),
+    }, { additionalProperties: false }),
+    { description: 'Missions to create, in intended order.' },
+  ),
+}, { additionalProperties: false })
+
+export const MissionInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  id: Type.Optional(Type.String({ description: 'Mission id, e.g. M1 (canonical; alias: missionId).' })),
+  missionId: Type.Optional(Type.String({ description: 'Alias for id; both are accepted.' })),
+  status: Type.Optional(enumOf(MISSION_STATUSES, { description: 'New lifecycle status.' })),
+  note: Type.Optional(Type.String({ description: 'Append a decision-log note.' })),
+  blocker: Type.Optional(Type.String({ description: 'Report a blocker (also sets status to blocked).' })),
+  clear_blockers: Type.Optional(Type.Boolean({ description: 'Clear all recorded blockers.' })),
+  clearBlockers: Type.Optional(Type.Boolean({ description: 'Alias for clear_blockers.' })),
+  task_done: Type.Optional(Type.String({ description: 'Mark the first open task containing this text as done.' })),
+  taskDone: Type.Optional(Type.String({ description: 'Alias for task_done.' })),
+  task_drop: Type.Optional(Type.String({ description: 'Mark the first open task containing this text as dropped.' })),
+  taskDrop: Type.Optional(Type.String({ description: 'Alias for task_drop.' })),
+  task_drop_reason: Type.Optional(Type.String({ description: 'Required with task_drop: why the task is legitimately descoped.' })),
+  taskDropReason: Type.Optional(Type.String({ description: 'Alias for task_drop_reason.' })),
+  scope: Type.Optional(Type.Array(Type.String(), { description: 'Tower only: replacement scope globs; bumps scopeGeneration.' })),
+  pause_cause: Type.Optional(enumOf(PAUSE_CAUSES, { description: 'With status=paused: why the mission was paused (default user).' })),
+  authorization: Type.Optional(Type.String({ description: 'Authorization reference recorded when resuming a user-paused mission.' })),
+}, { additionalProperties: false })
+
+export const StatusInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  missionId: Type.Optional(Type.String({ description: 'Return full detail for one mission instead of the dashboard list.' })),
+  offset: Type.Optional(Type.Integer({ minimum: 0, description: 'Mission list offset (default 0).' })),
+  limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 100, description: 'Mission list page size (default 20).' })),
+  includeGate: Type.Optional(Type.Boolean({ description: 'Compute tower_preflight-style gate digests for missions on this page.' })),
+  format: Type.Optional(enumOf(STATUS_FORMATS, { description: 'markdown returns the MISSIONS.md board text.' })),
+}, { additionalProperties: false })
+
+export const CompleteInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  missionId: Type.Optional(Type.String({ description: 'Mission id, e.g. M1 (canonical; alias: id).' })),
+  id: Type.Optional(Type.String({ description: 'Alias for missionId; both are accepted.' })),
+  report: Type.String({ description: 'Full completion report for the tower and the next review round.' }),
+  checks: Type.Optional(
+    Type.Array(
+      Type.Object({
+        name: Type.String({ description: 'What was checked.' }),
+        command: Type.Optional(Type.String({ description: 'Command or method used.' })),
+        exitCode: Type.Optional(Type.Integer({ description: 'Observed exit code.' })),
+        evidence: Type.Optional(Type.String({ description: 'Short evidence line/log reference.' })),
+      }, { additionalProperties: false }),
+      { description: 'Optional evidence ledger entries: {name, command?, exitCode?, evidence?}.' },
+    ),
+  ),
+}, { additionalProperties: false })
+
+export const ReviewInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  missionId: Type.Optional(Type.String({ description: 'Mission id, e.g. M1 (canonical; alias: id).' })),
+  id: Type.Optional(Type.String({ description: 'Alias for missionId; both are accepted.' })),
+  status: Type.String({ description: 'Verdict: "clean", or "p1-Nitems" / "p2-Nitems" with the number of findings at that priority.' }),
+  merge: enumOf(MERGE_VERDICTS, { description: 'Merge recommendation for the tower.' }),
+  findings: Type.String({ description: 'Full findings text (markdown); write "none" when clean.' }),
+  checks: Type.Optional(Type.Array(Type.String(), { description: 'Checklist items you verified.' })),
+  decision: Type.String({ description: 'The reasoning behind your verdict.' }),
+  breakGlassReason: Type.Optional(Type.String({ description: 'Tower-only exceptional self-review: why no independent reviewer was used.' })),
+}, { additionalProperties: false })
+
+export const PreflightInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  missionId: Type.Optional(Type.String({ description: 'Mission id, e.g. M1 (canonical; alias: id).' })),
+  id: Type.Optional(Type.String({ description: 'Alias for missionId; both are accepted.' })),
+}, { additionalProperties: false })

package/domain/contracts/tool-inputs/ops.js

@@ -0,0 +1,75 @@
+// tower_init / tower_doctor / tower_recover / tower_test / tower_batch /
+// tower_resource / tower_import_legacy / tower_legacy_map / tower_reload input
+// contracts. Pure TypeBox only; no I/O.
+import {
+  BATCH_ACTIONS,
+  LEASE_ACTIONS,
+  LEGACY_MAP_ACTIONS,
+  RECOVERY_ACTIONS,
+} from '../../vocabulary.js'
+import { Type, enumOf, untypedObject } from './shared.js'
+
+export const InitInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  base: Type.Optional(Type.String({ description: 'Optional local base branch (defaults to the checked-out branch).' })),
+  autoGitInit: Type.Optional(Type.Boolean({ description: 'Run git init (and an empty initial commit) when repoRoot is not a repository yet.' })),
+  snapshotDirty: Type.Optional(Type.Boolean({ description: 'Snapshot uncommitted tracked changes into a dangling commit used as the mission baseline (untracked files are not included).' })),
+  reanchor: Type.Optional(Type.Boolean({ description: 'Update the recorded base when no mission is active.' })),
+}, { additionalProperties: false })
+
+export const DoctorInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+}, { additionalProperties: false })
+
+export const RecoverInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  action: enumOf(RECOVERY_ACTIONS, { description: 'Recovery action.' }),
+  confirm: Type.Optional(Type.String({ description: 'Required literal CLEAR_STALE_LOCK for clear-stale-lock.' })),
+}, { additionalProperties: false })
+
+export const TestInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  missionId: Type.String({ description: 'Mission id, e.g. M1 (alias: id).' }),
+  id: Type.Optional(Type.String({ description: 'Alias for missionId.' })),
+}, { additionalProperties: false })
+
+export const BatchInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  action: enumOf(BATCH_ACTIONS, { description: 'Batch operation.' }),
+  missionIds: Type.Optional(Type.Array(Type.String(), { description: 'Exact mission ids in this batch (create).' })),
+  exclusions: Type.Optional(Type.Array(Type.String(), { description: 'Paused legacy mission ids excluded from the batch.' })),
+  requiredChecks: Type.Optional(Type.Array(Type.String(), { description: 'Check names every build member must record (default ["check"]).' })),
+  receiptPaths: Type.Optional(Type.Array(Type.String(), { description: 'Exact relative receipt files checked at close.' })),
+  batchId: Type.Optional(Type.String({ description: 'Batch id (status/close/abandon).' })),
+  reason: Type.Optional(Type.String({ description: 'Reason recorded when abandoning a batch.' })),
+  checks: Type.Optional(Type.Array(untypedObject(), { description: 'Close-time extra check evidence.' })),
+  treeTip: Type.Optional(Type.String({ description: 'Expected reviewed/tested commit for close evidence.' })),
+  receiptHashes: Type.Optional(untypedObject('Relative receipt path -> sha256 observed by the caller.')),
+}, { additionalProperties: false })
+
+export const ResourceInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  action: enumOf(LEASE_ACTIONS, { description: 'Lease operation.' }),
+  name: Type.Optional(Type.String({ description: 'Lease name, e.g. plugin-load or heavy-ci.' })),
+  holder: Type.Optional(Type.String({ description: 'Holder label (defaults to the caller).' })),
+  token: Type.Optional(Type.String({ description: 'Release token; generated on acquire when omitted.' })),
+  ttlMs: Type.Optional(Type.Integer({ minimum: 1000, description: 'Lease lifetime (default leases.ttlMs).' })),
+  force: Type.Optional(Type.Boolean({ description: 'Explicitly release an expired lease (token still required).' })),
+}, { additionalProperties: false })
+
+export const ImportLegacyInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  sourcePath: Type.String({ description: 'Absolute path to the legacy JSON state file.' }),
+}, { additionalProperties: false })
+
+export const LegacyMapInput = Type.Object({
+  repoRoot: Type.String({ description: 'Absolute path inside the target Git repository.' }),
+  action: enumOf(LEGACY_MAP_ACTIONS, { description: 'Mapping operation.' }),
+  sourceHash: Type.Optional(Type.String({ description: 'Legacy snapshot sha256 (map).' })),
+  oldId: Type.Optional(Type.String({ description: 'Legacy mission id (map).' })),
+  newMissionId: Type.Optional(Type.String({ description: 'Current mission id; optional audit pointer.' })),
+}, { additionalProperties: false })
+
+export const ReloadInput = Type.Object({
+  repoRoot: Type.Optional(Type.String({ description: 'Optional repository root; when present the caller must be the tower.' })),
+}, { additionalProperties: false, required: [] })