@entelligentsia/forgecli 1.0.3 → 1.0.14

package/dist/forge-payload/tools/postflight-gate.cjs

@@ -0,0 +1,252 @@
+'use strict';
+
+// postflight-gate.cjs — evaluates a phase's declared outputs block against
+// the filesystem / task state, post-subagent-return. Returns structured failure
+// data so the orchestrator (run-task.ts) can halt before FSM advance when outputs
+// are not satisfied.
+//
+// Pure function: only fs.existsSync / fs.statSync / fs.readFileSync. No writes,
+// no network, no LLM, no process spawns.
+//
+// CLI shim: node postflight-gate.cjs --phase <name> --task <taskId>
+// Exit codes: 0 (ok), 1 (guard failed), 2 (invalid args / parse error)
+// Stdout on exit 1: single JSON line { phase, reasonCode, detail, remediation }
+//
+// New reasonCodes (FORGE-S26-T19):
+//   output-missing  — artifact path does not exist
+//   output-stub     — artifact exists but size < min= bytes
+//   require-failed  — require predicate over state field failed
+//   tool-error      — internal parse or store-read failure
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/**
+ * postflight({ phase, outputs, state, substitutions })
+ *
+ * @param {string} phase - Phase name (e.g. 'implement')
+ * @param {object} outputs - Parsed outputs spec from parseOutputs() — { [phase]: { artifacts, require } }
+ * @param {object} [state] - Task/bug state for require predicates (e.g. { task: {...} })
+ * @param {object} [substitutions] - Template variable substitutions (e.g. { engineering, sprint, task })
+ * @returns {{ ok: boolean, missing: string[], reasonCode: string, detail: string, remediation: string }}
+ */
+function postflight({ phase, outputs, state = {}, substitutions = {} }) {
+  const spec = outputs && outputs[phase];
+  if (!spec) {
+    // No outputs block for this phase — pass through (no-op)
+    return { ok: true, missing: [], reasonCode: null, detail: '', remediation: '' };
+  }
+
+  const missing = [];
+
+  for (const art of spec.artifacts || []) {
+    const resolved = applySubstitutions(art.path, substitutions);
+    let exists = false;
+    let size = 0;
+    try {
+      const st = fs.statSync(resolved);
+      exists = st.isFile();
+      size = st.size;
+    } catch (_) {
+      exists = false;
+    }
+    if (!exists) {
+      missing.push(`output-missing: artifact absent: ${resolved}`);
+    } else if (size < (art.minBytes || 0)) {
+      missing.push(
+        `output-stub: artifact too small: ${resolved} (${size} bytes, need >= ${art.minBytes})`,
+      );
+    }
+  }
+
+  for (const pred of spec.require || []) {
+    if (!evalPredicate(pred, state)) {
+      missing.push(
+        `require-failed: ${describePredicate(pred)} (got ${JSON.stringify(readField(pred.field, state))})`,
+      );
+    }
+  }
+
+  if (missing.length === 0) {
+    return { ok: true, missing: [], reasonCode: null, detail: '', remediation: '' };
+  }
+
+  const { reasonCode, detail, remediation } = buildStructuredFailure(phase, missing);
+  return { ok: false, missing, reasonCode, detail, remediation };
+}
+
+function applySubstitutions(template, subs) {
+  return template.replace(/\{(\w+)\}/g, (full, key) => {
+    if (Object.prototype.hasOwnProperty.call(subs, key)) return String(subs[key]);
+    return full;
+  });
+}
+
+function readField(dottedPath, state) {
+  const parts = dottedPath.split('.');
+  let cur = state;
+  for (const p of parts) {
+    if (cur === null || cur === undefined) return undefined;
+    cur = cur[p];
+  }
+  return cur;
+}
+
+function evalPredicate(pred, state) {
+  const actual = readField(pred.field, state);
+  switch (pred.op) {
+    case '==':
+      return String(actual) === String(pred.value);
+    case '!=':
+      return String(actual) !== String(pred.value);
+    case 'in':
+      return (pred.value || []).map(String).includes(String(actual));
+    default:
+      throw new Error(`postflight-gate: unknown predicate op "${pred.op}"`);
+  }
+}
+
+function describePredicate(pred) {
+  if (pred.op === 'in') return `${pred.field} in [${(pred.value || []).join(', ')}]`;
+  return `${pred.field} ${pred.op} ${pred.value}`;
+}
+
+function buildStructuredFailure(phase, missing) {
+  let reasonCode = 'tool-error';
+  const detailParts = [];
+
+  for (const m of missing) {
+    detailParts.push(m);
+    if (reasonCode === 'tool-error') {
+      if (/^output-missing/i.test(m)) {
+        reasonCode = 'output-missing';
+      } else if (/^output-stub/i.test(m)) {
+        reasonCode = 'output-stub';
+      } else if (/^require-failed/i.test(m)) {
+        reasonCode = 'require-failed';
+      }
+    }
+  }
+
+  const detail = detailParts.join('; ');
+
+  const remediationMap = {
+    'output-missing': 'Re-run the phase that produces this artifact (e.g. /forge:implement), then retry.',
+    'output-stub': 'The artifact was produced but appears incomplete (stub). Ensure the phase wrote a complete file.',
+    'require-failed': 'Correct the task/bug state so it satisfies the postflight require predicate, then retry.',
+    'tool-error': 'Check the outputs block configuration and store records; run node .forge/tools/postflight-gate.cjs manually for diagnostics.',
+  };
+
+  return {
+    reasonCode,
+    detail,
+    remediation: remediationMap[reasonCode],
+  };
+}
+
+module.exports = { postflight };
+
+// CLI shim — only runs when invoked directly
+if (require.main === module) {
+  const args = parseArgs(process.argv.slice(2));
+  if (!args.phase || !args.task) {
+    process.stderr.write('Usage: postflight-gate.cjs --phase <phaseName> --task <taskId>\n');
+    process.exit(2);
+  }
+
+  const { parseOutputs } = require('./parse-gates.cjs');
+
+  // Resolve config
+  let engineeringRoot = 'engineering';
+  try {
+    const cfg = JSON.parse(fs.readFileSync(path.resolve(process.cwd(), '.forge/config.json'), 'utf8'));
+    if (cfg.paths && cfg.paths.engineering) engineeringRoot = cfg.paths.engineering;
+  } catch (_) { /* fall back to default */ }
+
+  // Load task record
+  let taskRecord = null;
+  try {
+    const store = require('./store.cjs');
+    taskRecord = store.getTask(args.task);
+  } catch (_) {
+    // store.cjs not available or task not found — continue with substitutions from args
+  }
+
+  // Build substitutions
+  const sprintId = taskRecord ? taskRecord.sprintId : undefined;
+  const substitutions = {
+    engineering: engineeringRoot,
+    sprint: sprintId,
+    task: args.task,
+  };
+
+  // Load workflow markdown (scan .forge/workflows/ for phase)
+  const workflowMd = loadWorkflowMarkdown(args.phase);
+  if (!workflowMd) {
+    process.stderr.write(`postflight-gate: no outputs block defined for phase "${args.phase}" — skipping\n`);
+    process.exit(0);
+  }
+
+  let outputs;
+  try {
+    outputs = parseOutputs(workflowMd);
+  } catch (err) {
+    process.stderr.write(`postflight-gate: ${err.message}\n`);
+    process.exit(2);
+  }
+
+  if (!outputs[args.phase]) {
+    process.stderr.write(`postflight-gate: no outputs block for phase "${args.phase}" — skipping\n`);
+    process.exit(0);
+  }
+
+  // Build state from task record
+  const state = {};
+  if (taskRecord) state.task = taskRecord;
+
+  const result = postflight({ phase: args.phase, outputs, state, substitutions });
+
+  if (result.ok) process.exit(0);
+
+  process.stderr.write(`Postflight guard failed for phase "${args.phase}":\n`);
+  for (const m of result.missing) process.stderr.write(`  - ${m}\n`);
+
+  // Emit structured JSON on stdout for orchestrators
+  process.stdout.write(JSON.stringify({
+    phase: args.phase,
+    reasonCode: result.reasonCode,
+    detail: result.detail,
+    remediation: result.remediation,
+  }) + '\n');
+  process.exit(1);
+}
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--phase') out.phase = argv[++i];
+    else if (a === '--task') out.task = argv[++i];
+  }
+  return out;
+}
+
+function loadWorkflowMarkdown(phaseName) {
+  const workflowsDir = path.resolve(process.cwd(), '.forge/workflows');
+  let entries;
+  try {
+    entries = fs.readdirSync(workflowsDir).filter((f) => f.endsWith('.md'));
+  } catch (_) {
+    return null;
+  }
+  const fencePattern = new RegExp('^```outputs\\s+phase=' + escapeRegex(phaseName) + '\\s*$', 'm');
+  for (const entry of entries) {
+    const md = fs.readFileSync(path.join(workflowsDir, entry), 'utf8');
+    if (fencePattern.test(md)) return md;
+  }
+  return null;
+}
+
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/forge-payload/tools/preflight-gate.cjs

@@ -113,7 +113,49 @@ function describePredicate(pred) {
   return `${pred.field} ${pred.op} ${pred.value}`;
 }
 
-module.exports = { preflight, resolveTaskArtifactDir, resolveSprintArtifactDir };
+module.exports = { preflight, resolveTaskArtifactDir, resolveSprintArtifactDir, deriveSprintTaskFromArtifactPath };
+
+// Derive {sprint} and {task} substitutions directly from a task's artifact path
+// (task.path) when that path is a directory under `<engineeringRoot>/sprints/`.
+//
+// task.path is the authoritative artifact location — it is where the plan /
+// implement phases actually write PLAN.md, REVIEW.md, etc. Splitting it tolerates
+// ANY nesting depth and ANY on-disk naming, so a single rule covers both the
+// modern 2-level layout (`sprints/<sprint>/<task>/`) and legacy 3-level layouts
+// (`sprints/<sprint>/tasks/<task>/`) whose on-disk sprint dir name need not equal
+// sprintId (e.g. sprintId "S19" → dir "sprint_19_platform_ux_improvements"). The
+// directory-scan resolution (resolveSprintArtifactDir + resolveTaskArtifactDir)
+// cannot express the `tasks/` nesting, which is what broke review-plan preflight
+// for heterogeneous-layout projects (walkinto.in S19/S32/S33).
+//
+//   {task}   = the last path segment (the artifact directory name)
+//   {sprint} = everything between `sprints/` and that last segment, joined by "/"
+//
+// File-vs-dir guard: if task.path ends in a filename (has an extension), the
+// artifact directory is its PARENT — strip the filename first. This prevents the
+// bogus `.../TASK_PROMPT.md/PLAN.md` (ENOTDIR) seen when a project stores
+// task.path as a file inside the artifact dir.
+//
+// Returns null when the path is absent, or not under `<engineeringRoot>/sprints/`
+// (e.g. a forge/ source-file path — see regression S12-T06), or resolves to
+// fewer than 2 directory segments. In every null case the caller falls back to
+// the directory-scan resolution, preserving prior behaviour.
+function deriveSprintTaskFromArtifactPath(taskPath, engineeringRoot) {
+  if (!taskPath) return null;
+  let norm = String(taskPath).replace(/\\/g, '/').replace(/\/+$/, '');
+  // File-vs-dir guard — drop a trailing filename so we split on the dir.
+  if (/\.[a-zA-Z0-9]+$/.test(norm)) {
+    norm = norm.replace(/\/[^/]*$/, '');
+  }
+  const er = String(engineeringRoot || 'engineering').replace(/\/+$/, '');
+  const prefix = er + '/sprints/';
+  if (!norm.startsWith(prefix)) return null;
+  const segs = norm.slice(prefix.length).split('/').filter(Boolean);
+  if (segs.length < 2) return null;
+  const task = segs[segs.length - 1];
+  const sprint = segs.slice(0, -1).join('/');
+  return { sprint, task };
+}
 
 // CLI shim: `node preflight-gate.cjs --phase <name> --task <taskId> [--bug <bugId>] [--workflow <name>]`
 // exit codes: 0 ok, 1 gate(s) failed, 2 invalid args / missing definitions
@@ -246,10 +288,18 @@ if (require.main === module) {
   // name is used both as the {sprint} substitution and as the directory in
   // which resolveTaskArtifactDir scans for task subdirectories.
   const sprintId = taskRecord ? taskRecord.sprintId : undefined;
-  const resolvedSprintDir = sprintId
-    ? (resolveSprintArtifactDir(sprintId, engineeringRoot) || sprintId)
-    : undefined;
-  const taskArtifactDir = resolveTaskArtifactDir(taskRecord, engineeringRoot, undefined, resolvedSprintDir);
+  // Primary resolution: derive {sprint}/{task} straight from task.path (the
+  // authoritative artifact directory). This honours arbitrary layout nesting —
+  // including legacy 3-level `sprints/<sprint>/tasks/<task>/` trees the
+  // directory-scan resolution below cannot express. Falls back to the scan when
+  // task.path is not an artifact dir under sprints/ (e.g. a forge/ source file).
+  const derived = taskRecord ? deriveSprintTaskFromArtifactPath(taskRecord.path, engineeringRoot) : null;
+  const resolvedSprintDir = derived
+    ? derived.sprint
+    : (sprintId ? (resolveSprintArtifactDir(sprintId, engineeringRoot) || sprintId) : undefined);
+  const taskArtifactDir = derived
+    ? derived.task
+    : resolveTaskArtifactDir(taskRecord, engineeringRoot, undefined, resolvedSprintDir);
   // Fallback: if task.path points to a file (e.g., TASK_PROMPT.md) we want
   // the *directory* segment, not the filename. Without this, a project that
   // stores task.path as the prompt file would propagate "TASK_PROMPT.md" as
@@ -299,9 +349,56 @@ if (require.main === module) {
   if (result.ok) process.exit(0);
   process.stderr.write(`Gate failed for phase "${args.phase}":\n`);
   for (const m of result.missing) process.stderr.write(`  - ${m}\n`);
+  // Emit structured JSON on stdout for orchestrators to parse and render.
+  // Shape: { phase, reasonCode, detail, remediation }
+  const structured = buildStructuredFailure(args.phase, result.missing);
+  process.stdout.write(JSON.stringify(structured) + '\n');
   process.exit(1);
 }
 
+// Build a structured gate-failure object for orchestrators.
+// Maps the human-readable `missing[]` strings to a typed { phase, reasonCode, detail, remediation }.
+// reasonCode is derived from the dominant failure pattern:
+//   artifact-missing            — artifact missing / too small
+//   predecessor-verdict-missing — after-clause verdict absent or wrong
+//   illegal-status              — require/forbid predicate fired
+//   tool-error                  — internal error / unrecognised pattern
+// When multiple failures exist, reasonCode reflects the first recognised pattern;
+// detail combines all messages; only a single JSON object is ever emitted.
+function buildStructuredFailure(phase, missing) {
+  let reasonCode = 'tool-error';
+  const detailParts = [];
+
+  for (const m of missing) {
+    detailParts.push(m);
+    if (reasonCode === 'tool-error') {
+      if (/^artifact (missing|too small)/i.test(m)) {
+        reasonCode = 'artifact-missing';
+      } else if (/^predecessor verdict (missing|unreadable)/i.test(m) || /verdict is "/i.test(m)) {
+        reasonCode = 'predecessor-verdict-missing';
+      } else if (/^(require failed|forbid triggered)/i.test(m)) {
+        reasonCode = 'illegal-status';
+      }
+    }
+  }
+
+  const detail = detailParts.join('; ');
+
+  const remediationMap = {
+    'artifact-missing': `Re-run the phase that produces this artifact (e.g. /forge:plan or /forge:implement), then retry.`,
+    'predecessor-verdict-missing': `Ensure the predecessor review phase completed and recorded a verdict via set-summary, then retry.`,
+    'illegal-status': `Correct the task/bug status (use store-cli update-status) so it satisfies the gate predicate, then retry.`,
+    'tool-error': `Check the gate configuration and store records for this task; run node .forge/tools/preflight-gate.cjs manually for diagnostics.`,
+  };
+
+  return {
+    phase,
+    reasonCode,
+    detail,
+    remediation: remediationMap[reasonCode],
+  };
+}
+
 function parseArgs(argv) {
   const out = {};
   for (let i = 0; i < argv.length; i++) {

package/dist/forge-payload/tools/store-cli.cjs

@@ -55,6 +55,7 @@ const { validateRecord, NULLABLE_FIELDS } = require('./lib/validate.js');
 
 // FORGE-S22-T03: suggestion engine for "Did you mean?" on validation/transition errors
 const { suggest, suggestEntityType, formatSuggestion } = require('./lib/suggest.cjs');
+const { resolveSummaryFilename, PHASE_TO_KIND } = require('./lib/artifact-kinds.cjs');
 
 // Valid phase keys for summaries (dot-delimited → underscore in JSON key)
 const VALID_SUMMARY_PHASES = new Set(['plan', 'review_plan', 'implementation', 'code_review', 'validation', 'triage', 'approve']);
@@ -432,8 +433,8 @@ Commands:
   progress-clear <sprintOrBugId>              Clear (truncate) the progress log
   write-collation-state '<json>'             Write COLLATION_STATE.json
   validate <entity> '<json>'                  Validate against schema without writing
-  set-summary <taskId> <phase> <jsonFile>     Set a phase summary on a task record
-  set-bug-summary <bugId> <phase> <jsonFile>  Set a phase summary on a bug record
+  set-summary <taskId> <phase> [<jsonFile>]     Set a phase summary on a task record (sidecar auto-resolved from record.path when jsonFile omitted)
+  set-bug-summary <bugId> <phase> [<jsonFile>]  Set a phase summary on a bug record (sidecar auto-resolved from record.path when jsonFile omitted)
   describe <entity>                           Print the JSON Schema for an entity
   template <entity>                           Print a canonical sample record (required fields populated)
 
@@ -1289,9 +1290,50 @@ function _setSummaryOnEntity(entityKind, entityId, phase, summaryFilePath) {
     process.exit(1);
   }
 
+  // Load entity first — its `path` is the authoritative artifact directory and
+  // is needed both to self-resolve the sidecar (when no file arg is given) and
+  // to merge the summary below.
+  const record = entityKind === 'task' ? store.getTask(entityId) : store.getBug(entityId);
+  if (!record) {
+    console.error(`${entityKind} not found: ${entityId}`);
+    process.exit(1);
+  }
+
+  // ADR artifact-resolution Phase 1: when the caller omits the JSON file, derive
+  // the sidecar from record.path + the canonical phase→filename map. The agent
+  // never hand-builds the path (kills the Class-1 failures + the arity bug).
+  let selfResolved = false;
+  if (!summaryFilePath) {
+    if (typeof record.path !== 'string' || record.path.length === 0) {
+      console.error(`Cannot self-resolve summary sidecar: ${entityKind} ${entityId} has no "path". Pass an explicit <jsonFile>.`);
+      process.exit(1);
+    }
+    // record.path is the entity directory; defensively strip a trailing filename.
+    const dir = /\.(md|json)$/i.test(record.path) ? path.dirname(record.path) : record.path;
+    summaryFilePath = path.join(dir, resolveSummaryFilename(entityKind, phase));
+    selfResolved = true;
+  }
+
   // Read and validate summary JSON
   if (!fs.existsSync(summaryFilePath)) {
-    console.error(`Summary file not found: ${summaryFilePath}`);
+    // v1.0.10: self-resolve looks for the CANONICAL filename. If an agent wrote a
+    // non-canonical sidecar (e.g. VALIDATE-SUMMARY.json via the Write tool instead
+    // of forge_artifact's VALIDATION-SUMMARY.json), surface the near-name file so
+    // the error is fixable in one step rather than a silent dead-end.
+    let hint = '';
+    if (selfResolved) {
+      try {
+        const dir = path.dirname(summaryFilePath);
+        const expected = path.basename(summaryFilePath);
+        const nearby = fs.readdirSync(dir).filter((f) => f !== expected && f.endsWith('.json') && /summary/i.test(f));
+        if (nearby.length > 0) {
+          const kind = PHASE_TO_KIND[phase];
+          hint = ` (expected ${expected}; found ${nearby.join(', ')} in the same dir — write the sidecar via ` +
+            `forge_artifact artifact:"${kind}", or rename it to ${expected})`;
+        }
+      } catch (_) { /* dir unreadable — fall back to the plain message */ }
+    }
+    console.error(`Summary file not found: ${summaryFilePath}${hint}`);
     process.exit(1);
   }
 
@@ -1309,14 +1351,7 @@ function _setSummaryOnEntity(entityKind, entityId, phase, summaryFilePath) {
     process.exit(1);
   }
 
-  // Load entity
-  const record = entityKind === 'task' ? store.getTask(entityId) : store.getBug(entityId);
-  if (!record) {
-    console.error(`${entityKind} not found: ${entityId}`);
-    process.exit(1);
-  }
-
-  // Merge summary
+  // Merge summary (record was loaded above for path resolution)
   if (!record.summaries) record.summaries = {};
   record.summaries[phase] = summary;
 
@@ -1394,8 +1429,8 @@ function cmdSetSummary() {
   const phase       = args[2];
   const summaryFile = args[3];
 
-  if (!taskId || !phase || !summaryFile) {
-    console.error('Usage: store-cli.cjs set-summary <taskId> <phase> <jsonFile>');
+  if (!taskId || !phase) {
+    console.error('Usage: store-cli.cjs set-summary <taskId> <phase> [<jsonFile>]');
     process.exit(1);
   }
 
@@ -1407,8 +1442,8 @@ function cmdSetBugSummary() {
   const phase       = args[2];
   const summaryFile = args[3];
 
-  if (!bugId || !phase || !summaryFile) {
-    console.error('Usage: store-cli.cjs set-bug-summary <bugId> <phase> <jsonFile>');
+  if (!bugId || !phase) {
+    console.error('Usage: store-cli.cjs set-bug-summary <bugId> <phase> [<jsonFile>]');
     process.exit(1);
   }
 

package/dist/forge-payload/tools/substitute-placeholders.cjs

@@ -120,10 +120,11 @@ const RUNTIME_PASSTHROUGH_KEYS = new Set([
  * project prefix via getCommandsSubdir() — see walkBasePack.
  */
 const SUBDIR_OUTPUT_MAP = {
-  personas:  path.join('.forge', 'personas'),
-  skills:    path.join('.forge', 'skills'),
-  workflows: path.join('.forge', 'workflows'),
-  templates: path.join('.forge', 'templates'),
+  personas:       path.join('.forge', 'personas'),
+  skills:         path.join('.forge', 'skills'),
+  workflows:      path.join('.forge', 'workflows'),
+  templates:      path.join('.forge', 'templates'),
+  'workflows-js': path.join('.claude', 'workflows'),
 };
 
 /**

package/dist/forge-payload/tools/verify-phase.cjs

@@ -194,6 +194,14 @@ function verifyPhase2(cwd, kbPath) {
 
 const PHASE3_DIRS = ['workflows', 'personas', 'skills', 'templates'];
 
+// JS workflow files that substitute-placeholders.cjs emits from
+// base-pack/workflows-js/ into .claude/workflows/ (FORGE-S28-T01).
+// These are checked in addition to the .forge/ directory checks.
+const PHASE3_JS_FILES = [
+  path.join('.claude', 'workflows', 'wfl-run-task.js'),
+  path.join('.claude', 'workflows', 'wfl-run-sprint.js'),
+];
+
 function verifyPhase3(cwd) {
   const missing = [];
   const checked = [];
@@ -213,6 +221,15 @@ function verifyPhase3(cwd) {
     }
   }
 
+  // Assert generated JS workflow files are present (FORGE-S28-T01)
+  for (const relFile of PHASE3_JS_FILES) {
+    checked.push(relFile);
+    const absFile = path.join(cwd, relFile);
+    if (!fs.existsSync(absFile)) {
+      missing.push(relFile);
+    }
+  }
+
   return {
     phase: 3,
     ok: missing.length === 0,

package/node_modules/@earendil-works/pi-agent-core/dist/harness/agent-harness.d.ts

@@ -36,6 +36,7 @@ export declare class AgentHarness<TSkill extends Skill = Skill, TPromptTemplate
     private createStreamFn;
     private drainQueuedMessages;
     private createLoopConfig;
+    private validateUniqueNames;
     private validateToolNames;
     private flushPendingSessionWrites;
     private handleAgentEvent;
@@ -69,9 +70,12 @@ export declare class AgentHarness<TSkill extends Skill = Skill, TPromptTemplate
         label?: string;
     }): Promise<NavigateTreeResult>;
     getModel(): Model<any>;
-    getThinkingLevel(): ThinkingLevel;
     setModel(model: Model<any>): Promise<void>;
+    getThinkingLevel(): ThinkingLevel;
     setThinkingLevel(level: ThinkingLevel): Promise<void>;
+    getTools(): TTool[];
+    setTools(tools: TTool[], activeToolNames?: string[]): Promise<void>;
+    getActiveTools(): TTool[];
     setActiveTools(toolNames: string[]): Promise<void>;
     getSteeringMode(): QueueMode;
     setSteeringMode(mode: QueueMode): Promise<void>;
@@ -81,7 +85,6 @@ export declare class AgentHarness<TSkill extends Skill = Skill, TPromptTemplate
     setResources(resources: AgentHarnessResources<TSkill, TPromptTemplate>): Promise<void>;
     getStreamOptions(): AgentHarnessStreamOptions;
     setStreamOptions(streamOptions: AgentHarnessStreamOptions): Promise<void>;
-    setTools(tools: TTool[], activeToolNames?: string[]): Promise<void>;
     abort(): Promise<AbortResult>;
     waitForIdle(): Promise<void>;
     subscribe(listener: (event: AgentHarnessEvent<TSkill, TPromptTemplate>, signal?: AbortSignal) => Promise<void> | void): () => void;