@farmslot/agent-runtime 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## Unreleased
+
+- Active-development baseline; add user-facing changes here before release or package publication.
+
+## 0.1.0 - 2026-07-06
+
+### Added
+
+- Add `buildRecipeQualityArtifact()` and `farmslot-agent recipe-quality build` so agents can generate validator-compliant `recipe-quality.json` artifacts from compact verdict/reason/finding inputs.
+- Introduce `@farmslot/agent-runtime` for task-local `mark`, `SIGNAL.json`, worker terminal contract, and task artifact checks.
+- Add `farmslot-agent` CLI with `mark`, `artifact-check`, `install-mark`, and `contract resolve` commands.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arthur Breton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,58 @@
+# @farmslot/agent-runtime
+
+Live agent task lifecycle tools for Farmslot-compatible runs.
+
+Public reference: https://farmslot.io/docs/reference/agent-runtime
+
+This package owns the reusable task-dir runtime surface:
+
+- `mark` and checklist timing updates;
+- worker-owned `SIGNAL.json` writes;
+- worker terminal contract resolution and linting;
+- closeout artifact checks;
+- `recipe-quality.json` builder/generator for worker-authored quality artifacts.
+
+It does not execute recipes. Recipe graph execution belongs in
+`@farmslot/recipe-harness`, and schemas/validators belong in `@farmslot/protocol`.
+
+## CLI
+
+```bash
+farmslot-agent install-mark <task-dir> --task TASK.md --signal SIGNAL.json
+farmslot-agent mark <task-md> <signal-json> complete --mark-last
+farmslot-agent artifact-check <task-dir> --require-recipe-quality-if-recipe
+farmslot-agent recipe-quality build --input recipe-quality-input.json --output artifacts/recipe-quality.json
+farmslot-agent contract resolve --flow fix-bug
+```
+
+## Compatibility
+
+Legacy script paths in `@farmslot/skills` and `scripts/quality/` delegate here
+for one migration window. New integrations should call `farmslot-agent`, install
+a task-local `./mark` shim, or import the explicit script subpaths.
+
+## Source layout
+
+- `bin/`: CLI entry point for task-local helper installation, marking, artifact checks, and terminal contract resolution.
+- `scripts/`: Runtime scripts that can be called directly by task files and compatibility shims.
+- `src/`: Public package constants and typed runtime helpers such as `buildRecipeQualityArtifact()`.
+- `test/`: Node TAP-style behavior tests for package exports, checklist marking, and artifact contract checks.
+
+## Maintenance rules
+
+- Keep runtime behavior here, not in `@farmslot/skills`; skills should teach and install, then delegate.
+- Keep protocol schemas and pure validators in `@farmslot/protocol`; this package may consume them but should not own them.
+- Preserve script subpath exports while task templates, remote slots, and compatibility shims depend on direct script paths.
+- Update package readiness, CI filters, docs, and `CHANGELOG.md` when adding bins, exports, or required artifacts.
+
+## Local quality
+
+```bash
+yarn workspace @farmslot/agent-runtime build
+yarn workspace @farmslot/agent-runtime test
+node scripts/quality/check-farmslot-package-readiness.mjs --packages @farmslot/agent-runtime
+```
+
+## License
+
+MIT. See [LICENSE](LICENSE).

package/bin/farmslot-agent.mjs

@@ -0,0 +1,481 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const require = createRequire(import.meta.url);
+
+function usage(exitCode = 0) {
+  const text = [
+    'Usage: farmslot-agent <command> [options]',
+    '',
+    'Commands:',
+    '  mark <task-md> <signal-json> <args...>',
+    '  artifact-check <task-dir> [args...]',
+    '  install-mark <task-dir> [--task TASK.md] [--signal SIGNAL.json]',
+    '  recipe-quality build [--input input.json] [--output artifacts/recipe-quality.json]',
+    '    (flags override top-level input fields; training fields are merged)',
+    '  contract resolve --flow <flow> [--project-config path] [--mode mode]',
+  ].join('\n');
+  (exitCode === 0 ? console.log : console.error)(text);
+  process.exit(exitCode);
+}
+
+function runNode(script, args) {
+  const result = spawnSync(process.execPath, [script, ...args], { stdio: 'inherit' });
+  process.exit(result.status ?? 1);
+}
+
+function readJsonFile(filePath) {
+  return JSON.parse(readFileSync(path.resolve(filePath), 'utf8'));
+}
+
+function readJsonInput(inputPath) {
+  if (!inputPath || inputPath === '-') {
+    return JSON.parse(readFileSync(0, 'utf8'));
+  }
+  return readJsonFile(inputPath);
+}
+
+function parseBooleanFlag(name, value) {
+  if (value === true || value === 'true') return true;
+  if (value === false || value === 'false') return false;
+  throw new Error(`${name} must be true or false`);
+}
+
+function isNodeModuleNotFoundError(error) {
+  return Boolean(error && typeof error === 'object' && error.code === 'ERR_MODULE_NOT_FOUND');
+}
+
+function pushFlagValue(target, key, value) {
+  const current = target[key];
+  if (current == null) target[key] = [value];
+  else current.push(value);
+}
+
+const RECIPE_QUALITY_INPUT_KEYS = new Set([
+  'verdict',
+  'reasons',
+  'compact',
+  'betterVersionGuidance',
+  'better_version_guidance',
+  'dimensions',
+  'structuralFindings',
+  'structural_findings',
+  'contextualFindings',
+  'contextual_findings',
+  'suggestedRecipeDelta',
+  'suggested_recipe_delta',
+  'trainingFields',
+  'training_fields',
+  'producer',
+  'fallbackUsed',
+  'fallback_used',
+  'fallbackSource',
+  'fallback_source',
+  'legacyTask',
+  'legacy_task',
+  'artifactRequired',
+  'artifact_required',
+  'sourceSignals',
+  'source_signals',
+  'meta',
+  'extra',
+]);
+
+const RECIPE_QUALITY_COMPACT_KEYS = new Set(['verdict', 'reasons', 'better_version_guidance']);
+
+const RECIPE_QUALITY_META_KEYS = new Set([
+  'producer',
+  'fallback_used',
+  'fallback_source',
+  'legacy_task',
+  'artifact_required',
+  'source_signals',
+]);
+
+function unknownKeys(value, allowed) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return [];
+  return Object.keys(value).filter((key) => !allowed.has(key));
+}
+
+function validateRecipeQualityCompact(input) {
+  const compact = input.compact;
+  if (compact == null) return;
+  if (typeof compact !== 'object' || Array.isArray(compact)) {
+    throw new Error('recipe-quality input compact must be a JSON object when provided');
+  }
+  const unknown = unknownKeys(compact, RECIPE_QUALITY_COMPACT_KEYS);
+  if (unknown.length > 0) {
+    throw new Error(`recipe-quality input compact contains unknown key(s): ${unknown.join(', ')}`);
+  }
+  if (compact.verdict != null) {
+    throw new Error('recipe-quality input compact.verdict is output-only; use top-level verdict');
+  }
+}
+
+function validateRecipeQualityMeta(input) {
+  const meta = input.meta;
+  if (meta == null) return;
+  if (typeof meta !== 'object' || Array.isArray(meta)) {
+    throw new Error('recipe-quality input meta must be a JSON object when provided');
+  }
+  const unknown = unknownKeys(meta, RECIPE_QUALITY_META_KEYS);
+  if (unknown.length > 0) {
+    throw new Error(`recipe-quality input meta contains unknown key(s): ${unknown.join(', ')}`);
+  }
+}
+
+function validateRecipeQualityInputKeys(input) {
+  const unknown = Object.keys(input).filter((key) => !RECIPE_QUALITY_INPUT_KEYS.has(key));
+  if (unknown.length > 0) {
+    throw new Error(`recipe-quality input contains unknown key(s): ${unknown.join(', ')}`);
+  }
+}
+
+function valuesEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+function rejectConflict(leftLabel, left, rightLabel, right) {
+  if (left !== undefined && right !== undefined && !valuesEqual(left, right)) {
+    throw new Error(`recipe-quality input ${leftLabel} conflicts with ${rightLabel}`);
+  }
+}
+
+function validateRecipeQualityInputConflicts(input) {
+  rejectConflict(
+    'betterVersionGuidance',
+    input.betterVersionGuidance,
+    'better_version_guidance',
+    input.better_version_guidance,
+  );
+  rejectConflict(
+    'structuralFindings',
+    input.structuralFindings,
+    'structural_findings',
+    input.structural_findings,
+  );
+  rejectConflict(
+    'contextualFindings',
+    input.contextualFindings,
+    'contextual_findings',
+    input.contextual_findings,
+  );
+  rejectConflict(
+    'suggestedRecipeDelta',
+    input.suggestedRecipeDelta,
+    'suggested_recipe_delta',
+    input.suggested_recipe_delta,
+  );
+  rejectConflict('trainingFields', input.trainingFields, 'training_fields', input.training_fields);
+  rejectConflict('fallbackUsed', input.fallbackUsed, 'fallback_used', input.fallback_used);
+  rejectConflict('fallbackSource', input.fallbackSource, 'fallback_source', input.fallback_source);
+  rejectConflict('legacyTask', input.legacyTask, 'legacy_task', input.legacy_task);
+  rejectConflict(
+    'artifactRequired',
+    input.artifactRequired,
+    'artifact_required',
+    input.artifact_required,
+  );
+  rejectConflict('sourceSignals', input.sourceSignals, 'source_signals', input.source_signals);
+  rejectConflict('reasons', input.reasons, 'compact.reasons', input.compact?.reasons);
+  rejectConflict(
+    'betterVersionGuidance',
+    input.betterVersionGuidance ?? input.better_version_guidance,
+    'compact.better_version_guidance',
+    input.compact?.better_version_guidance,
+  );
+  rejectConflict('producer', input.producer, 'meta.producer', input.meta?.producer);
+  rejectConflict(
+    'fallbackUsed',
+    input.fallbackUsed ?? input.fallback_used,
+    'meta.fallback_used',
+    input.meta?.fallback_used,
+  );
+  rejectConflict(
+    'fallbackSource',
+    input.fallbackSource ?? input.fallback_source,
+    'meta.fallback_source',
+    input.meta?.fallback_source,
+  );
+  rejectConflict(
+    'legacyTask',
+    input.legacyTask ?? input.legacy_task,
+    'meta.legacy_task',
+    input.meta?.legacy_task,
+  );
+  rejectConflict(
+    'artifactRequired',
+    input.artifactRequired ?? input.artifact_required,
+    'meta.artifact_required',
+    input.meta?.artifact_required,
+  );
+  rejectConflict(
+    'sourceSignals',
+    input.sourceSignals ?? input.source_signals,
+    'meta.source_signals',
+    input.meta?.source_signals,
+  );
+}
+
+function optionalObject(name, value) {
+  if (value == null) return {};
+  if (typeof value === 'object' && !Array.isArray(value)) return value;
+  throw new Error(`${name} must be a JSON object when provided`);
+}
+
+function mergeRecipeQualityInputs(fileInput, flagInput) {
+  return {
+    ...fileInput,
+    ...flagInput,
+    trainingFields: {
+      ...optionalObject('trainingFields', fileInput.trainingFields),
+      ...optionalObject('trainingFields', flagInput.trainingFields),
+    },
+  };
+}
+
+function parseRecipeQualityBuildArgs(args) {
+  const parsed = { input: null, output: null, flags: {} };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    const next = (flag) => {
+      const value = args[++i];
+      if (value === undefined) throw new Error(`${flag} requires a value`);
+      return value;
+    };
+    if (arg === '--input') parsed.input = next(arg);
+    else if (arg.startsWith('--input=')) parsed.input = arg.slice('--input='.length);
+    else if (arg === '--output') parsed.output = next(arg);
+    else if (arg.startsWith('--output=')) parsed.output = arg.slice('--output='.length);
+    else if (arg === '--verdict') parsed.flags.verdict = next(arg);
+    else if (arg.startsWith('--verdict=')) parsed.flags.verdict = arg.slice('--verdict='.length);
+    else if (arg === '--reason') pushFlagValue(parsed.flags, 'reasons', next(arg));
+    else if (arg.startsWith('--reason='))
+      pushFlagValue(parsed.flags, 'reasons', arg.slice('--reason='.length));
+    else if (arg === '--guidance') pushFlagValue(parsed.flags, 'betterVersionGuidance', next(arg));
+    else if (arg.startsWith('--guidance='))
+      pushFlagValue(parsed.flags, 'betterVersionGuidance', arg.slice('--guidance='.length));
+    else if (arg === '--delta') pushFlagValue(parsed.flags, 'suggestedRecipeDelta', next(arg));
+    else if (arg.startsWith('--delta='))
+      pushFlagValue(parsed.flags, 'suggestedRecipeDelta', arg.slice('--delta='.length));
+    else if (arg === '--proof-mode')
+      parsed.flags.trainingFields = { ...parsed.flags.trainingFields, proof_mode: next(arg) };
+    else if (arg.startsWith('--proof-mode='))
+      parsed.flags.trainingFields = {
+        ...parsed.flags.trainingFields,
+        proof_mode: arg.slice('--proof-mode='.length),
+      };
+    else if (arg === '--project')
+      parsed.flags.trainingFields = { ...parsed.flags.trainingFields, project: next(arg) };
+    else if (arg.startsWith('--project='))
+      parsed.flags.trainingFields = {
+        ...parsed.flags.trainingFields,
+        project: arg.slice('--project='.length),
+      };
+    else if (arg === '--flow-type')
+      parsed.flags.trainingFields = { ...parsed.flags.trainingFields, flow_type: next(arg) };
+    else if (arg.startsWith('--flow-type='))
+      parsed.flags.trainingFields = {
+        ...parsed.flags.trainingFields,
+        flow_type: arg.slice('--flow-type='.length),
+      };
+    else if (arg === '--claim-is-visual')
+      parsed.flags.trainingFields = { ...parsed.flags.trainingFields, claim_is_visual: true };
+    else if (arg.startsWith('--claim-is-visual='))
+      parsed.flags.trainingFields = {
+        ...parsed.flags.trainingFields,
+        claim_is_visual: parseBooleanFlag(
+          '--claim-is-visual',
+          arg.slice('--claim-is-visual='.length),
+        ),
+      };
+    else if (arg === '--producer') parsed.flags.producer = next(arg);
+    else if (arg.startsWith('--producer=')) parsed.flags.producer = arg.slice('--producer='.length);
+    else if (arg === '--artifact-required')
+      parsed.flags.artifactRequired = parseBooleanFlag(arg, next(arg));
+    else if (arg.startsWith('--artifact-required='))
+      parsed.flags.artifactRequired = parseBooleanFlag(
+        '--artifact-required',
+        arg.slice('--artifact-required='.length),
+      );
+    else if (arg === '--legacy-task') parsed.flags.legacyTask = true;
+    else if (arg.startsWith('--legacy-task='))
+      parsed.flags.legacyTask = parseBooleanFlag(
+        '--legacy-task',
+        arg.slice('--legacy-task='.length),
+      );
+    else if (arg === '--source-signal') pushFlagValue(parsed.flags, 'sourceSignals', next(arg));
+    else if (arg.startsWith('--source-signal='))
+      pushFlagValue(parsed.flags, 'sourceSignals', arg.slice('--source-signal='.length));
+    else throw new Error(`unknown option ${arg}`);
+  }
+  return parsed;
+}
+
+function normalizeRecipeQualityInput(input) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new Error('recipe-quality input must be a JSON object');
+  }
+  validateRecipeQualityInputKeys(input);
+  validateRecipeQualityCompact(input);
+  validateRecipeQualityMeta(input);
+  validateRecipeQualityInputConflicts(input);
+  return {
+    verdict: input.verdict,
+    reasons: input.reasons ?? input.compact?.reasons,
+    betterVersionGuidance:
+      input.betterVersionGuidance ??
+      input.better_version_guidance ??
+      input.compact?.better_version_guidance,
+    dimensions: input.dimensions,
+    structuralFindings: input.structuralFindings ?? input.structural_findings,
+    contextualFindings: input.contextualFindings ?? input.contextual_findings,
+    suggestedRecipeDelta: input.suggestedRecipeDelta ?? input.suggested_recipe_delta,
+    trainingFields: input.trainingFields ?? input.training_fields,
+    producer: input.producer ?? input.meta?.producer,
+    fallbackUsed: input.fallbackUsed ?? input.fallback_used ?? input.meta?.fallback_used,
+    fallbackSource: input.fallbackSource ?? input.fallback_source ?? input.meta?.fallback_source,
+    legacyTask: input.legacyTask ?? input.legacy_task ?? input.meta?.legacy_task,
+    artifactRequired:
+      input.artifactRequired ?? input.artifact_required ?? input.meta?.artifact_required,
+    sourceSignals: input.sourceSignals ?? input.source_signals ?? input.meta?.source_signals,
+    extra: input.extra,
+  };
+}
+
+async function buildRecipeQuality(args) {
+  const parsed = parseRecipeQualityBuildArgs(args);
+  const fileInput = parsed.input ? normalizeRecipeQualityInput(readJsonInput(parsed.input)) : {};
+  const input = mergeRecipeQualityInputs(fileInput, parsed.flags);
+  let runtime;
+  const distEntry = path.join(packageRoot, 'dist', 'index.js');
+  try {
+    runtime = await import(pathToFileURL(distEntry).href);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const missingDistEntry =
+      isNodeModuleNotFoundError(error) &&
+      (message.includes(`Cannot find module '${distEntry}'`) ||
+        message.includes(`Cannot find module ${pathToFileURL(distEntry).href}`));
+    if (missingDistEntry) {
+      throw new Error(
+        `farmslot-agent recipe-quality build requires the compiled package at ${distEntry}. Run yarn workspace @farmslot/agent-runtime build in source checkouts. Original error: ${message}`,
+      );
+    }
+    throw error;
+  }
+  const artifact = runtime.buildRecipeQualityArtifact(input);
+  const text = `${JSON.stringify(artifact, null, 2)}\n`;
+  if (parsed.output) {
+    const outputPath = path.resolve(parsed.output);
+    mkdirSync(path.dirname(outputPath), { recursive: true });
+    writeFileSync(outputPath, text);
+    console.log(`wrote ${outputPath}`);
+  } else {
+    process.stdout.write(text);
+  }
+}
+
+function parseInstallMarkArgs(args) {
+  const parsed = { taskDir: args[0], task: 'TASK.md', signal: 'SIGNAL.json' };
+  for (let i = 1; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--task') {
+      parsed.task = args[++i] || parsed.task;
+    } else if (arg.startsWith('--task=')) {
+      parsed.task = arg.slice('--task='.length);
+    } else if (arg === '--signal') {
+      parsed.signal = args[++i] || parsed.signal;
+    } else if (arg.startsWith('--signal=')) {
+      parsed.signal = arg.slice('--signal='.length);
+    } else {
+      usage(2);
+    }
+  }
+  if (!parsed.taskDir) usage(2);
+  return parsed;
+}
+
+function installMark(args) {
+  const parsed = parseInstallMarkArgs(args);
+  const taskDir = path.resolve(parsed.taskDir);
+  mkdirSync(taskDir, { recursive: true });
+  const markPath = path.join(taskDir, 'mark');
+  const binPath = path.join(packageRoot, 'bin', 'farmslot-agent.mjs');
+  writeFileSync(
+    markPath,
+    [
+      '#!/usr/bin/env bash',
+      'set -euo pipefail',
+      'DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"',
+      `node ${JSON.stringify(binPath)} mark "$DIR/${parsed.task}" "$DIR/${parsed.signal}" "$@"`,
+      '',
+    ].join('\n'),
+    { mode: 0o755 },
+  );
+  console.log(`installed ${markPath}`);
+}
+
+function parseContractResolveArgs(args) {
+  const parsed = { flow: null, mode: null, projectConfig: null };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--flow') parsed.flow = args[++i] || null;
+    else if (arg.startsWith('--flow=')) parsed.flow = arg.slice('--flow='.length);
+    else if (arg === '--mode') parsed.mode = args[++i] || null;
+    else if (arg.startsWith('--mode=')) parsed.mode = arg.slice('--mode='.length);
+    else if (arg === '--project-config') parsed.projectConfig = args[++i] || null;
+    else if (arg.startsWith('--project-config='))
+      parsed.projectConfig = arg.slice('--project-config='.length);
+    else usage(2);
+  }
+  if (!parsed.flow) usage(2);
+  return parsed;
+}
+
+function resolveContract(args) {
+  const parsed = parseContractResolveArgs(args);
+  const { resolveWorkerTerminalContract } = require('../scripts/worker-terminal-contract.cjs');
+  const projectConfig = parsed.projectConfig
+    ? (JSON.parse(readFileSync(path.resolve(parsed.projectConfig), 'utf8')).worker_terminal ?? null)
+    : null;
+  const contract = resolveWorkerTerminalContract(projectConfig, parsed.flow, {
+    mode: parsed.mode,
+  });
+  console.log(JSON.stringify(contract, null, 2));
+}
+
+async function main() {
+  const [command, subcommand, ...rest] = process.argv.slice(2);
+  if (!command || command === '--help' || command === '-h') usage(0);
+
+  if (command === 'mark') {
+    runNode(
+      path.join(packageRoot, 'scripts', 'mark-checklist-step.cjs'),
+      [subcommand, ...rest].filter((arg) => arg !== undefined),
+    );
+  } else if (command === 'artifact-check') {
+    runNode(
+      path.join(packageRoot, 'scripts', 'check-task-artifact-contract.mjs'),
+      [subcommand, ...rest].filter((arg) => arg !== undefined),
+    );
+  } else if (command === 'install-mark') {
+    installMark([subcommand, ...rest].filter((arg) => arg !== undefined));
+  } else if (command === 'contract' && subcommand === 'resolve') {
+    resolveContract(rest);
+  } else if (command === 'recipe-quality' && subcommand === 'build') {
+    await buildRecipeQuality(rest);
+  } else {
+    usage(2);
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export declare const AGENT_RUNTIME_PACKAGE = "@farmslot/agent-runtime";
+export declare const AGENT_RUNTIME_SCRIPT_EXPORTS: {
+    readonly markChecklistStep: "@farmslot/agent-runtime/scripts/mark-checklist-step.cjs";
+    readonly workerTerminalContract: "@farmslot/agent-runtime/scripts/worker-terminal-contract.cjs";
+    readonly checkTaskArtifactContract: "@farmslot/agent-runtime/scripts/check-task-artifact-contract.mjs";
+};
+export * from './recipe-quality.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,4BAA4B,CAAC;AAE/D,eAAO,MAAM,4BAA4B;;;;CAI/B,CAAC;AAEX,cAAc,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export const AGENT_RUNTIME_PACKAGE = '@farmslot/agent-runtime';
+export const AGENT_RUNTIME_SCRIPT_EXPORTS = {
+    markChecklistStep: '@farmslot/agent-runtime/scripts/mark-checklist-step.cjs',
+    workerTerminalContract: '@farmslot/agent-runtime/scripts/worker-terminal-contract.cjs',
+    checkTaskArtifactContract: '@farmslot/agent-runtime/scripts/check-task-artifact-contract.mjs',
+};
+export * from './recipe-quality.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,qBAAqB,GAAG,yBAAyB,CAAC;AAE/D,MAAM,CAAC,MAAM,4BAA4B,GAAG;IAC1C,iBAAiB,EAAE,yDAAyD;IAC5E,sBAAsB,EAAE,8DAA8D;IACtF,yBAAyB,EAAE,kEAAkE;CACrF,CAAC;AAEX,cAAc,qBAAqB,CAAC"}

package/dist/recipe-quality.d.ts

@@ -0,0 +1,27 @@
+import { type RecipeQualityArtifact, type RecipeQualityArtifactSource, type RecipeQualityVerdict } from '@farmslot/protocol';
+type RecipeQualityFallbackSource = Exclude<RecipeQualityArtifactSource, 'worker' | 'gateway'>;
+export interface RecipeQualityArtifactBuilderInput {
+    verdict: RecipeQualityVerdict;
+    reasons: string[];
+    betterVersionGuidance?: string[];
+    dimensions?: RecipeQualityArtifact['dimensions'];
+    structuralFindings?: RecipeQualityArtifact['structural_findings'];
+    contextualFindings?: RecipeQualityArtifact['contextual_findings'];
+    suggestedRecipeDelta?: string[];
+    trainingFields?: RecipeQualityArtifact['training_fields'];
+    producer?: RecipeQualityArtifactSource;
+    fallbackUsed?: boolean;
+    fallbackSource?: RecipeQualityFallbackSource;
+    legacyTask?: boolean;
+    artifactRequired?: boolean;
+    sourceSignals?: string[];
+    extra?: Record<string, unknown>;
+}
+export type BuiltRecipeQualityArtifact = RecipeQualityArtifact & Record<string, unknown>;
+/**
+ * Builds the canonical `artifacts/recipe-quality.json` payload from the compact
+ * fields agents are expected to know after a recipe-quality pass.
+ */
+export declare function buildRecipeQualityArtifact(input: RecipeQualityArtifactBuilderInput): BuiltRecipeQualityArtifact;
+export {};
+//# sourceMappingURL=recipe-quality.d.ts.map

package/dist/recipe-quality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recipe-quality.d.ts","sourceRoot":"","sources":["../src/recipe-quality.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAEhC,KAAK,oBAAoB,EAC1B,MAAM,oBAAoB,CAAC;AAE5B,KAAK,2BAA2B,GAAG,OAAO,CAAC,2BAA2B,EAAE,QAAQ,GAAG,SAAS,CAAC,CAAC;AAE9F,MAAM,WAAW,iCAAiC;IAChD,OAAO,EAAE,oBAAoB,CAAC;IAC9B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;IACjC,UAAU,CAAC,EAAE,qBAAqB,CAAC,YAAY,CAAC,CAAC;IACjD,kBAAkB,CAAC,EAAE,qBAAqB,CAAC,qBAAqB,CAAC,CAAC;IAClE,kBAAkB,CAAC,EAAE,qBAAqB,CAAC,qBAAqB,CAAC,CAAC;IAClE,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;IAChC,cAAc,CAAC,EAAE,qBAAqB,CAAC,iBAAiB,CAAC,CAAC;IAC1D,QAAQ,CAAC,EAAE,2BAA2B,CAAC;IACvC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,2BAA2B,CAAC;IAC7C,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,MAAM,MAAM,0BAA0B,GAAG,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AA+HzF;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,iCAAiC,GACvC,0BAA0B,CAuE5B"}