@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.10

package/dist/chunk-XB5RFZHH.js

@@ -0,0 +1,1217 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  changeWorktree,
+  handDown,
+  loadTask,
+  openTaskWorktree,
+  readChangeTasks
+} from "./chunk-IDGSU7JF.js";
+import {
+  buildEngineFor
+} from "./chunk-LK44ULGI.js";
+import {
+  slug,
+  writeGateRound
+} from "./chunk-7YYEKTYF.js";
+import {
+  conform,
+  readConformDeltas,
+  readTaskSteps,
+  renderTaskContext,
+  taskContext
+} from "./chunk-KC5DROFC.js";
+import {
+  readChangeFiles,
+  readRound,
+  roundsOf,
+  writeQuarantineItems
+} from "./chunk-47QE246J.js";
+import {
+  changeFolder,
+  changeStore
+} from "./chunk-XQ3YIV5R.js";
+import {
+  AdapterError,
+  createAdapters,
+  fileStepStore,
+  requireApproval
+} from "./chunk-NGPU2ARF.js";
+import {
+  scanEstate
+} from "./chunk-AY2IUF4K.js";
+import {
+  baseClonePath,
+  createGit,
+  toRepoRelative
+} from "./chunk-PGKHJYOB.js";
+import {
+  HandoffRuntime,
+  buildContextPack,
+  createRuntime,
+  quarantineItems,
+  toRunSummary
+} from "./chunk-5XDNUJ4P.js";
+import {
+  AgentDefinition,
+  ChecklistPack,
+  Finding,
+  RecordId,
+  RunSummary,
+  RuntimeKind,
+  api_exports,
+  changeBranch,
+  changesDirOf,
+  changesRelOf,
+  external_exports,
+  readRepoSpec,
+  require_dist,
+  runsDirOf,
+  runsRelOf,
+  stateDirOf,
+  taskBranch,
+  toCanonicalYaml
+} from "./chunk-577AJVRS.js";
+import {
+  writeFileAtomic
+} from "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/taskrun/dist/apply.js
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var FILE_FORMAT = `Give every file you change whole, in this form, and nothing else for code:
+
+=== file: <path from the repo root>
+<the whole new content>
+=== end file
+
+Delete a file with a line "=== delete: <path>". Write a short report of what you changed, and why, outside the blocks.`;
+function refusedPath(path) {
+  if (!path || path.startsWith("/") || /^[A-Za-z]:/.test(path) || path.includes("\\"))
+    return `${path || "(empty)"} is not a relative path inside the repo`;
+  const parts = path.split("/");
+  if (parts.includes("..") || parts.includes("."))
+    return `${path} leaves the repo`;
+  if (parts[0] === ".git")
+    return `${path} is Git's own data`;
+  if (path === ".specify/memory/constitution.md")
+    return `${path} is generated from the org pack`;
+  return void 0;
+}
+function parseAnswer(output) {
+  const lines = output.replace(/\r\n/g, "\n").split("\n");
+  const changes = [];
+  const report = [];
+  const problems = [];
+  for (let i = 0; i < lines.length; i++) {
+    const del = /^=== delete:\s*(.+?)\s*$/.exec(lines[i]);
+    if (del) {
+      changes.push({ path: del[1] });
+      continue;
+    }
+    const open = /^=== file:\s*(.+?)\s*$/.exec(lines[i]);
+    if (!open) {
+      report.push(lines[i]);
+      continue;
+    }
+    const body = [];
+    let j = i + 1;
+    for (; j < lines.length && lines[j] !== "=== end file"; j++)
+      body.push(lines[j]);
+    if (j >= lines.length)
+      problems.push(`the block for ${open[1]} has no "=== end file" line`);
+    changes.push({ path: open[1], content: body.join("\n") + "\n" });
+    i = j;
+  }
+  for (const c of changes) {
+    const why = refusedPath(c.path);
+    if (why)
+      problems.push(why);
+  }
+  return { changes, report: report.join("\n").trim(), problems };
+}
+async function applyChanges(worktree, changes) {
+  for (const c of changes) {
+    const why = refusedPath(c.path);
+    if (why)
+      throw new Error(why);
+  }
+  for (const c of changes) {
+    const full = join(worktree, c.path);
+    if (c.content === void 0)
+      await rm(full, { force: true });
+    else {
+      await mkdir(dirname(full), { recursive: true });
+      await writeFile(full, c.content, "utf8");
+    }
+  }
+  return changes.map((c) => c.path);
+}
+
+// packages/taskrun/dist/commands.js
+import { spawn } from "node:child_process";
+function shellCommandRunner() {
+  return (command, cwd, o = {}) => new Promise((resolve) => {
+    const child = spawn(command, {
+      cwd,
+      shell: true,
+      env: { ...process.env, ...o.env },
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => child.kill(), o.timeoutMs ?? 30 * 6e4);
+    child.stdout.setEncoding("utf8").on("data", (d) => stdout += d);
+    child.stderr.setEncoding("utf8").on("data", (d) => stderr += d);
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      resolve({ exitCode: null, stdout, stderr: stderr + e.message });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({ exitCode: code, stdout, stderr });
+    });
+  });
+}
+
+// packages/taskrun/dist/store.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readdir, readFile } from "node:fs/promises";
+import { join as join2 } from "node:path";
+var TaskRunState = external_exports.enum([
+  /** Plan-only finished: tasks/<task>/plan.md is written. */
+  "planned",
+  /** Hand-off mode: the person's assistant is doing the step. */
+  "waiting",
+  /** Draft finished with a passing build, committed on the task branch. */
+  "built",
+  /** Draft finished but the repo has no build command, so nothing was checked. */
+  "unverified",
+  /** The PR from the task branch to the change branch is open. */
+  "pr-open",
+  /** The build still fails after the allowed fix rounds, or a PR can't be opened: a person takes over. */
+  "needs-person",
+  /** The AI run itself failed. */
+  "failed"
+]);
+var RunLevel = external_exports.enum(["plan", "draft", "pr"]);
+var BuildAttempt = external_exports.strictObject({
+  n: external_exports.number().int().positive(),
+  /** The AI fix run that came before this build, if any. */
+  fixRun: external_exports.string().optional(),
+  command: external_exports.string(),
+  exitCode: external_exports.number().int().nullable(),
+  passed: external_exports.boolean(),
+  /** Log path relative to the metarepo (.runs/...). */
+  log: external_exports.string(),
+  at: external_exports.string()
+});
+var TaskRunRecord = external_exports.strictObject({
+  schemaVersion: external_exports.literal(1),
+  change: RecordId,
+  task: RecordId,
+  repo: RecordId,
+  level: RunLevel,
+  runtime: RuntimeKind,
+  engine: external_exports.enum(["speckit", "atticus"]),
+  by: external_exports.string().min(1),
+  branch: external_exports.string(),
+  /** Task worktree, relative to the metarepo. */
+  worktree: external_exports.string(),
+  state: TaskRunState,
+  /** Every AI run, in order (the first is the main run, then fix runs). */
+  runs: external_exports.array(external_exports.string()).default([]),
+  /** The hand-off run Atticus waits on. */
+  waiting: external_exports.string().optional(),
+  attempts: external_exports.array(BuildAttempt).default([]),
+  /** Files the run changed in the worktree. */
+  changed: external_exports.array(external_exports.string()).default([]),
+  commit: external_exports.string().optional(),
+  pr: external_exports.strictObject({ number: external_exports.number().int().positive(), url: external_exports.string() }).optional(),
+  startedAt: external_exports.string(),
+  finishedAt: external_exports.string().optional(),
+  notes: external_exports.array(external_exports.string()).default([])
+});
+var LEADING = [
+  "schemaVersion",
+  "change",
+  "task",
+  "repo",
+  "level",
+  "runtime",
+  "engine",
+  "by",
+  "branch",
+  "worktree",
+  "state"
+];
+var taskDir = (root, change, task) => join2(changeFolder(root, change), "tasks", task);
+async function saveTaskRun(root, r) {
+  const v = TaskRunRecord.parse(r);
+  await writeFileAtomic(join2(taskDir(root, v.change, v.task), "task-run.yaml"), toCanonicalYaml(v, LEADING));
+  return v;
+}
+async function readTaskRun(root, change, task) {
+  const text = await readFile(join2(taskDir(root, change, task), "task-run.yaml"), "utf8").catch(() => void 0);
+  return text === void 0 ? void 0 : TaskRunRecord.parse((0, import_yaml.parse)(text));
+}
+async function saveRunSummary(root, change, task, s) {
+  const rel = `tasks/${task}/runs/${s.runId}.yaml`;
+  await writeFileAtomic(join2(changeFolder(root, change), rel), toCanonicalYaml(RunSummary.parse(s), ["schemaVersion", "runId"]));
+  return rel;
+}
+async function findWaitingTaskRun(root, runId) {
+  const changes = changesDirOf(root);
+  for (const c of (await readdir(changes, { withFileTypes: true }).catch(() => [])).filter((d) => d.isDirectory())) {
+    for (const t of (await readdir(join2(changes, c.name, "tasks"), { withFileTypes: true }).catch(() => [])).filter((d) => d.isDirectory())) {
+      const r = await readTaskRun(root, c.name, t.name).catch(() => void 0);
+      if (r?.waiting === runId)
+        return r;
+    }
+  }
+  return void 0;
+}
+
+// packages/taskrun/dist/prompt.js
+import { readFile as readFile2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+var TASK_RUNNER = "task-runner";
+function taskRunnerAgent(t) {
+  const own = t.ctx.orgPack.agents.find((a) => a.id === TASK_RUNNER);
+  if (own)
+    return own;
+  return AgentDefinition.parse({
+    schemaVersion: 1,
+    id: TASK_RUNNER,
+    role: "developer",
+    description: "Implements one task of a change in its repo, with tests, within the approved design.",
+    inputs: ["stories", "design", "interfaces", "data", "mappings", "skills", "repo-code"],
+    outputArtifact: "code",
+    tokenBudget: t.ctx.orgPack.runtime.budgets.defaultTokens,
+    allowedRuntimes: ["hand-off", "model", "headless-claude-code", "mock", "replay"]
+  });
+}
+function instructions(p) {
+  const { t } = p;
+  const branch = taskBranch(t.change.id, t.task.id);
+  const feature = p.engine === "speckit" ? `The task's Spec Kit feature is \`specs/${t.task.id}/\` (spec.md, plan.md, data-model.md, contracts/, tasks.md): follow it, and keep tasks.md's boxes up to date.` : `The task file is \`.atticus/tasks/${t.task.id}.md\`.`;
+  const common = [
+    `# Run with AI: task ${t.task.id} of change ${t.change.id}`,
+    "",
+    `Task: ${t.task.title}. Repo: ${t.repo.id} (component ${t.component}), branch \`${branch}\`.`,
+    feature,
+    "",
+    "Rules that always hold:",
+    "- Stay inside the approved design. If the work needs an interface, table or system the design doesn't list, don't add it: say so in your report as a question for the architect.",
+    "- Never push, merge, deploy or touch a protected branch; Atticus raises the pull request with a person's approval.",
+    "- Don't edit `.specify/memory/constitution.md`: it is generated from the org pack.",
+    "- needs.md (when the change has one) is what the organisation needs of this change: follow its standards and patterns for this task, its story and the whole change. Its requests and processes are a person's to raise, never yours. An item marked not yet verified was read from a wiki and no person has checked it: follow it, and say in your report if it looks wrong for this code."
+  ];
+  if (p.buildLog)
+    return [
+      ...common,
+      "",
+      `## Fix the build (attempt ${p.buildLog.attempt})`,
+      "",
+      `\`${p.buildLog.command}\` failed after your last change. Its log is in the data below. Fix the cause in the code or tests; don't weaken or delete a test to make it pass.`,
+      "",
+      p.oneShot ? FILE_FORMAT : "Edit the files in the worktree, then stop."
+    ].join("\n");
+  if (p.level === "plan")
+    return [
+      ...common,
+      "",
+      "## Plan only",
+      "",
+      "Change no code. Write the plan for this task in Markdown: the files to add or change with what changes in each, the tests to write for each acceptance criterion, the order of the work, risks, and open questions for the architect. Write only the plan."
+    ].join("\n");
+  return [
+    ...common,
+    "",
+    "## Draft the change",
+    "",
+    "Make the code and test changes the task needs, tested against every acceptance criterion. Atticus runs the build afterwards and sends failures back to you.",
+    "",
+    p.oneShot ? FILE_FORMAT : `Work in \`${p.worktreeRel}\` only. When you are done, write a short report of what you changed and why.`
+  ].join("\n");
+}
+async function readIf(path) {
+  return readFile2(path, "utf8").then((t) => t.replace(/\r\n/g, "\n"), () => void 0);
+}
+async function taskPack(p) {
+  const { t } = p;
+  const agent = taskRunnerAgent(t);
+  const levels = t.ctx.orgPack.pack?.classification ?? [
+    "public",
+    "internal",
+    "confidential",
+    "restricted"
+  ];
+  const skills = t.ctx.orgPack.skills.filter((s) => s.status === "active" && (s.appliesTo.repoTypes.length === 0 || s.appliesTo.repoTypes.includes(t.repo.type)));
+  const sources = [
+    {
+      id: "0-instructions",
+      kind: "instruction",
+      origin: "atticus/taskrun",
+      text: instructions(p),
+      classification: "public",
+      trusted: true
+    },
+    ...skills.map((s) => ({
+      id: `skill-${s.id}`,
+      kind: "skill",
+      origin: `org-pack/process/skills/${s.id}/SKILL.md`,
+      text: `## Skill: ${s.name}
+
+${s.body.trim()}`,
+      classification: "public",
+      trusted: true
+    }))
+  ];
+  const artifact = (rel, priority) => {
+    const d = t.files.docs.get(rel);
+    if (d)
+      sources.push({
+        id: rel,
+        kind: "artifact",
+        origin: `${changesRelOf(t.root)}/${t.change.id}/${rel}`,
+        text: d.raw,
+        classification: "internal",
+        priority
+      });
+  };
+  const context = await taskContext(t.root, t.change.id, t.task.id).catch(() => void 0);
+  if (context)
+    sources.push({
+      id: "task-context",
+      kind: "artifact",
+      origin: `atticus task context ${t.change.id} ${t.task.id}`,
+      text: renderTaskContext(context).replace(/\r\n/g, "\n"),
+      classification: "internal",
+      priority: 35
+    });
+  for (const s of t.task.stories)
+    artifact(`stories/${s}.md`, 30);
+  for (const a of ["design.md", "interfaces.md", "mappings.md", "data.md"])
+    artifact(a, 20);
+  const needs = await readIf(join3(t.root, ...changesRelOf(t.root).split("/"), t.change.id, "needs.md"));
+  if (needs !== void 0)
+    sources.push({
+      id: "needs.md",
+      kind: "artifact",
+      origin: `${changesRelOf(t.root)}/${t.change.id}/needs.md`,
+      text: needs,
+      classification: "internal",
+      priority: 25
+    });
+  const featureFiles = p.engine === "speckit" ? ["spec.md", "plan.md", "data-model.md", "tasks.md", "research.md", "quickstart.md"].map((f) => `specs/${t.task.id}/${f}`) : [`.atticus/tasks/${t.task.id}.md`];
+  for (const f of featureFiles) {
+    const text = await readIf(join3(p.worktree, f));
+    if (text !== void 0)
+      sources.push({
+        id: `repo:${f}`,
+        kind: "code",
+        origin: `${t.repo.id}:${f}`,
+        text,
+        classification: "internal",
+        priority: 40
+      });
+  }
+  const listed = await p.git(["ls-files"], p.worktree).then((r) => r.stdout.trim().split("\n").filter(Boolean), () => []);
+  if (listed.length)
+    sources.push({
+      id: "repo:files",
+      kind: "code",
+      origin: `${t.repo.id}:git ls-files`,
+      text: `Files in ${t.repo.id}:
+${listed.slice(0, 400).join("\n")}${listed.length > 400 ? `
+(and ${listed.length - 400} more)` : ""}`,
+      classification: "internal",
+      priority: 10
+    });
+  if (p.buildLog)
+    sources.push({
+      id: `build-log-${p.buildLog.attempt}`,
+      kind: "document",
+      origin: `build: ${p.buildLog.command}`,
+      text: p.buildLog.text.split("\n").slice(-200).join("\n"),
+      classification: "internal",
+      priority: 50
+    });
+  return buildContextPack({
+    change: t.change.id,
+    agent: agent.id,
+    budget: t.ctx.orgPack.runtime.budgets.perAgent[agent.id] ?? agent.tokenBudget,
+    sources,
+    levels,
+    maxClassification: levels.includes("confidential") ? "confidential" : levels.at(-1),
+    now: p.now
+  });
+}
+
+// packages/taskrun/dist/run.js
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdir as mkdir3, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+
+// packages/taskrun/dist/conform.js
+var import_yaml2 = __toESM(require_dist(), 1);
+import { createHash, randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir as mkdir2, readdir as readdir2, readFile as readFile3, rm as rm2 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+import { fileURLToPath } from "node:url";
+var __atticus_import_meta_url = __atticusUrl("packages/taskrun/dist/conform.js");
+var CONFORM_GATE = "conform";
+var CONFORM_DIR = "conform";
+var ConformError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ConformError";
+  }
+};
+var stamp = () => (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+function conformScanDir(root, repo, commit2) {
+  const own = `${process.pid}-${randomBytes(4).toString("hex")}`;
+  return join4(stateDirOf(root), ".index", "conform", `${repo}-${commit2.slice(0, 12)}-${own}`);
+}
+function gitScanAt(root, git) {
+  return async (repo, commit2) => {
+    const base = baseClonePath(root, repo);
+    const dir = conformScanDir(root, repo, commit2);
+    await rm2(dir, { recursive: true, force: true });
+    await mkdir2(join4(dir, ".."), { recursive: true });
+    await git(["worktree", "add", "--detach", "--force", "--", dir, commit2], base);
+    try {
+      const s = await scanEstate({
+        root,
+        repos: [repo],
+        repoDir: () => dir,
+        repoState: async () => ({ commit: commit2, dirty: false })
+      });
+      const files = (await git(["ls-tree", "-r", "--name-only", commit2], base)).stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+      return {
+        records: s.records,
+        files,
+        problems: s.problems.filter((p) => !p.repo || p.repo === repo).map((p) => `${p.repo ? `${p.repo}: ` : ""}${p.source}: ${p.message}`)
+      };
+    } finally {
+      await git(["worktree", "remove", "--force", "--", dir], base).catch(() => void 0);
+      await rm2(dir, { recursive: true, force: true }).catch(() => void 0);
+      await git(["worktree", "prune"], base).catch(() => void 0);
+    }
+  };
+}
+var RULES_FILE = fileURLToPath(new URL("../rules/conform.yaml", __atticus_import_meta_url));
+async function loadConformRules() {
+  const pack = ChecklistPack.parse((0, import_yaml2.parse)(await readFile3(RULES_FILE, "utf8")));
+  return new Map(pack.rules.map((r) => [r.id, r]));
+}
+var FIX = {
+  missing: "Build what the step says on the branch, or change the target flow (atticus change architecture) if the design was wrong.",
+  "still-there": "Take the call out on the branch, or keep the step in the target flow if it should stay.",
+  unexpected: "Add a step that names it to the target flow if the change needs it, or take it out of the branch. Dismiss it as not relevant if it belongs elsewhere."
+};
+function conformFindingId(i) {
+  const column = i.check !== "column" ? "" : i.record ? `-${slug(i.record.split(".").pop())}` : `-${createHash("sha256").update(i.what).digest("hex").slice(0, 8)}`;
+  const subject = i.status === "unexpected" ? slug(i.record ?? i.what) : `${slug(i.flow ?? "")}-${i.item ?? "trigger"}${column}`;
+  return `conform-${i.status}-${i.check}-${subject}`.slice(0, 120).replace(/-+$/, "");
+}
+async function conformFindings(change, results, lines, now) {
+  const rules = await loadConformRules();
+  const out = [];
+  for (const r of results)
+    for (const i of r.items) {
+      if (i.status === "found")
+        continue;
+      const rule = rules.get(`conform.${i.status}`);
+      const artifact = i.flow ? `target-flows/${i.flow}.yaml` : "code";
+      const line = i.flow ? lines.get(`${i.flow}#${i.item ?? 0}`) : void 0;
+      const summary = i.what.length <= 200 ? i.what : `${i.what.slice(0, 197)}...`;
+      out.push(Finding.parse({
+        schemaVersion: 1,
+        id: conformFindingId(i),
+        kind: "issue",
+        change,
+        gate: CONFORM_GATE,
+        round: 1,
+        rule: rule.id,
+        layer: rule.layer,
+        lens: rule.lens,
+        severity: rule.severity,
+        artifact,
+        locator: i.flow ? line ? { line } : { heading: i.item ? `item ${i.item}` : "trigger" } : { record: i.record ?? r.repo },
+        summary,
+        why: rule.description ?? rule.title,
+        fix: { text: FIX[i.status] },
+        evidence: i.at.map((c) => c.source === "artifact" ? { source: "artifact", path: c.path, ...c.line ? { line: c.line } : {} } : {
+          source: "code",
+          repo: c.repo ?? r.repo,
+          path: c.path,
+          ...c.line ? { line: c.line } : {}
+        }),
+        waivable: rule.waivable,
+        state: "open",
+        createdAt: now
+      }));
+    }
+  return out;
+}
+async function readConformResults(root, change) {
+  const dir = join4(changeFolder(root, change), CONFORM_DIR);
+  const results = [];
+  const problems = [];
+  for (const f of (await readdir2(dir).catch(() => [])).sort()) {
+    if (!f.endsWith(".yaml"))
+      continue;
+    try {
+      const r = api_exports.ConformRepoResult.safeParse((0, import_yaml2.parse)(await readFile3(join4(dir, f), "utf8")));
+      if (r.success)
+        results.push(r.data);
+      else
+        problems.push(`${CONFORM_DIR}/${f}: ${r.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`);
+    } catch (e) {
+      problems.push(`${CONFORM_DIR}/${f}: ${e.message.split("\n")[0]}`);
+    }
+  }
+  return { results, problems };
+}
+async function deltasOf(root, change) {
+  const { deltas, problems } = await readConformDeltas(changeFolder(root, change));
+  const specs = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const d of deltas) {
+    if (!specs.has(d.delta.repo))
+      specs.set(d.delta.repo, (await readRepoSpec(root, d.delta.repo, { cacheRoot: root })).flows);
+    const today = specs.get(d.delta.repo).find((f) => f.id === d.delta.flow);
+    if (d.delta.change !== "new" && !today)
+      problems.push(`${d.file}: ${d.delta.flow} isn't in ${d.delta.repo}'s spec, so the steps it ${d.delta.change === "remove" ? "removes" : "changes"} are checked without today's flow.`);
+    out.push(today ? { ...d, today } : d);
+  }
+  return { deltas: out, problems };
+}
+function linesOf(deltas) {
+  const m = /* @__PURE__ */ new Map();
+  for (const d of deltas) {
+    m.set(`${d.delta.flow}#0`, d.triggerLine);
+    d.stepLines.forEach((l, i) => m.set(`${d.delta.flow}#${i + 1}`, l));
+  }
+  return m;
+}
+async function conformChange(root, change, o = {}) {
+  await changeStore(root).read(change).catch(() => {
+    throw new ConformError("not-found", `There is no change ${change}.`);
+  });
+  const git = o.git ?? createGit();
+  const now = o.now ?? stamp();
+  const { deltas, problems } = await deltasOf(root, change);
+  if (!deltas.length)
+    return { results: [], problems, flows: 0 };
+  const tasks = await readTaskSteps(changeFolder(root, change));
+  let taskRepo;
+  if (o.task) {
+    const t = o.task.toLowerCase();
+    const listed = readChangeTasks(await readChangeFiles(changeFolder(root, change))).find((x) => x.id === t);
+    const flow = [...tasks].find(([, v]) => v === t)?.[0].split("#")[0];
+    taskRepo = listed?.repo ?? deltas.find((d) => d.delta.flow === flow)?.delta.repo;
+    if (!taskRepo)
+      throw new ConformError("not-found", `There is no task ${o.task} in ${change}'s tasks.md or stories.`);
+  }
+  const repos = o.repo ? [o.repo] : taskRepo ? [taskRepo] : [...new Set(deltas.map((d) => d.delta.repo))].sort();
+  if (o.repo && !deltas.some((d) => d.delta.repo === o.repo))
+    problems.push(`No target flow of ${change} is in ${o.repo}; only what it adds is checked.`);
+  const scanAt = o.scanAt ?? gitScanAt(root, git);
+  const results = [];
+  for (const repo of repos) {
+    const ref = o.ref ?? (o.task ? taskBranch(change, o.task.toLowerCase()) : changeBranch(change));
+    const base = baseClonePath(root, repo);
+    if (!existsSync(base))
+      throw new ConformError("refused", `There is no base clone of ${repo}; run atticus workspace sync first.`);
+    const commit2 = await git(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], base).then((x) => x.stdout.trim(), () => "");
+    if (!commit2) {
+      problems.push(`${repo} has no ${ref} yet, so there is no code to check: open the change (atticus workspace open ${change} --repos ${repo}) or name the branch with --ref.`);
+      continue;
+    }
+    const from = await git(["merge-base", commit2, "HEAD"], base).then((x) => x.stdout.trim() || commit2, () => commit2);
+    const after = await scanAt(repo, commit2);
+    const before = from === commit2 ? after : await scanAt(repo, from);
+    const scope = o.task ? [...tasks].filter(([, v]) => v === o.task.toLowerCase()).map(([k]) => ({ flow: k.split("#")[0], item: Number(k.split("#")[1]) })) : void 0;
+    const repoProblems = [.../* @__PURE__ */ new Set([...before.problems, ...after.problems])];
+    if (o.task && !scope?.length)
+      repoProblems.push(`The stories don't say which target-flow steps task ${o.task} builds, so every step of ${repo}'s target flows is checked.`);
+    const r = conform({
+      repo,
+      deltas,
+      ...scope?.length ? { scope } : {},
+      tasks,
+      before: before.records,
+      after: after.records,
+      files: after.files
+    });
+    const count = (s) => r.items.filter((i) => i.status === s).length;
+    const result = {
+      schemaVersion: 1,
+      change,
+      repo,
+      ref,
+      commit: commit2,
+      base: from,
+      ...o.task ? { task: o.task.toLowerCase() } : {},
+      checkedAt: now,
+      counts: {
+        found: count("found"),
+        missing: count("missing"),
+        stillThere: count("still-there"),
+        unexpected: count("unexpected")
+      },
+      items: r.items,
+      unchecked: r.unchecked,
+      problems: repoProblems
+    };
+    await writeFileAtomic(join4(changeFolder(root, change), CONFORM_DIR, `${repo}.yaml`), toCanonicalYaml(result, [
+      "schemaVersion",
+      "change",
+      "repo",
+      "ref",
+      "commit",
+      "base",
+      "task",
+      "checkedAt",
+      "counts",
+      "status",
+      "check",
+      "flow",
+      "item"
+    ]));
+    results.push(result);
+  }
+  const stored = await readConformResults(root, change);
+  problems.push(...stored.problems);
+  const round = await writeGateRound(root, change, CONFORM_GATE, await conformFindings(change, stored.results, linesOf(deltas), now), now);
+  return {
+    results,
+    ...round.round ? { round: round.round } : {},
+    problems,
+    flows: deltas.length
+  };
+}
+async function conformanceOf(root, change) {
+  const c = await changeStore(root).read(change).catch(() => void 0);
+  if (!c)
+    return void 0;
+  const { deltas, problems } = await readConformDeltas(changeFolder(root, change));
+  const stored = await readConformResults(root, change);
+  const rounds = await roundsOf(root, change, CONFORM_GATE).catch(() => []);
+  const round = rounds.at(-1);
+  const states = /* @__PURE__ */ new Map();
+  if (round)
+    for (const f of (await readRound(root, change, CONFORM_GATE, round)).findings)
+      states.set(f.finding.id, f.finding.state);
+  return {
+    change,
+    title: c.title,
+    flows: deltas.length,
+    results: stored.results.map((r) => ({
+      ...r,
+      items: r.items.map((i) => {
+        if (i.status === "found")
+          return i;
+        const id = conformFindingId(i);
+        return { ...i, finding: { id, state: states.get(id) ?? "open" } };
+      })
+    })),
+    gate: CONFORM_GATE,
+    ...round ? { round } : {},
+    problems: [...problems, ...stored.problems]
+  };
+}
+async function conformAfterBuild(c) {
+  if (c.record.state !== "built" || !c.record.commit)
+    return;
+  const change = c.t.change.id;
+  const task = c.t.task.id;
+  try {
+    const r = await conformChange(c.root, change, {
+      task,
+      ref: c.record.branch,
+      git: c.git,
+      now: c.now().toISOString().replace(/\.\d{3}Z$/, "Z")
+    });
+    if (!r.flows)
+      return;
+    const x = r.results[0];
+    const cmd = `atticus change conform ${change} --task ${task}`;
+    if (!x) {
+      c.record.notes.push(`The code wasn't checked against the design: ${r.problems[0] ?? "nothing to check"} (${cmd}).`);
+      return;
+    }
+    const n = x.counts;
+    const parts = [
+      n.missing ? `${n.missing} missing` : "",
+      n.stillThere ? `${n.stillThere} still there` : "",
+      n.unexpected ? `${n.unexpected} not in the design` : ""
+    ].filter(Boolean);
+    c.record.notes.push(parts.length ? `Checked against the design: ${parts.join(", ")}; the findings are on the conform gate (${cmd}).` : `Checked against the design: ${n.found} found, nothing missing or unexpected (${cmd}).`);
+  } catch (e) {
+    c.record.notes.push(`The code couldn't be checked against the design: ${e.message.split("\n")[0]}`);
+  }
+}
+
+// packages/taskrun/dist/run.js
+var TaskRunError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "TaskRunError";
+  }
+};
+var LEVEL_RANK = { plan: 0, draft: 1, pr: 2 };
+var AUTONOMY = {
+  "plan-only": "plan",
+  draft: "draft",
+  "draft-and-pr": "pr"
+};
+var stamp2 = (d) => d.toISOString().replace(/\.\d{3}Z$/, "Z");
+function gitHostOf(root, t) {
+  return createAdapters(t.ctx.orgPack.runtime, {}, { store: fileStepStore(root), root, procedures: t.ctx.orgPack.procedures }).gitHost;
+}
+async function summarise(c, run) {
+  await saveRunSummary(c.root, c.t.change.id, c.t.task.id, toRunSummary(run));
+  if (!c.record.runs.includes(run.runId))
+    c.record.runs.push(run.runId);
+}
+async function aiStep(c, buildLog) {
+  const level = c.record.level;
+  const oneShot = c.runtime.kind !== "hand-off" && c.runtime.kind !== "headless-claude-code";
+  const pack = await taskPack({
+    t: c.t,
+    level,
+    engine: c.record.engine,
+    worktree: c.worktree,
+    worktreeRel: c.record.worktree,
+    oneShot,
+    git: c.git,
+    ...buildLog ? { buildLog } : {},
+    now: c.now()
+  });
+  const request = {
+    change: c.t.change.id,
+    agent: taskRunnerAgent(c.t),
+    pack,
+    outputPath: `tasks/${c.t.task.id}/${level === "plan" ? "plan.md" : "report.md"}`
+  };
+  const prepared = await c.runtime.prepare(request);
+  await writeQuarantineItems(c.root, c.t.change.id, prepared.runId, quarantineItems(pack.defences ?? []));
+  if (c.runtime instanceof HandoffRuntime) {
+    await writeFile2(join5(runsDirOf(c.root), request.change, prepared.runId, "prompt.md"), handoffPrompt(c, prepared), "utf8");
+  }
+  const run = await c.runtime.run(prepared.runId);
+  await summarise(c, run);
+  return run;
+}
+function handoffPrompt(c, run) {
+  const out = `${changesRelOf(c.root)}/${c.t.change.id}/${run.request.outputPath}`;
+  return [
+    `# ${run.request.agent.id}: task ${c.t.task.id} of change ${c.t.change.id}`,
+    "",
+    c.record.level === "plan" ? `Write the plan to ${out}. Change no code.` : `Make the changes in ${c.record.worktree} (branch ${c.record.branch}) only, then write a short report of what you changed to ${out}.`,
+    "",
+    run.request.pack.prompt.trimEnd(),
+    "",
+    `When you are done, run: atticus handoff done ${run.runId}`,
+    ""
+  ].join("\n");
+}
+async function build(c, runId, fixRun) {
+  const command = c.t.repo.build;
+  if (!command)
+    return void 0;
+  const n = c.record.attempts.length + 1;
+  const res = await c.commands(command, c.worktree);
+  const logRel = `${runsRelOf(c.root)}/${c.t.change.id}/${runId}/build-${n}.log`;
+  await mkdir3(join5(runsDirOf(c.root), c.t.change.id, runId), { recursive: true });
+  await writeFile2(join5(c.root, logRel), `$ ${command}
+${res.stdout}${res.stderr ? `
+${res.stderr}` : ""}
+(exit ${res.exitCode ?? "none"})
+`, "utf8");
+  const a = {
+    n,
+    ...fixRun ? { fixRun } : {},
+    command,
+    exitCode: res.exitCode,
+    passed: res.exitCode === 0,
+    log: logRel,
+    at: stamp2(c.now())
+  };
+  c.record.attempts.push(a);
+  return a;
+}
+async function applyAnswer(c, run) {
+  if (c.runtime.kind === "headless-claude-code") {
+    const changed = await c.git(["status", "--porcelain"], c.worktree);
+    for (const l of changed.stdout.split("\n").filter(Boolean)) {
+      const p = l.slice(3).trim();
+      if (!c.record.changed.includes(p))
+        c.record.changed.push(p);
+    }
+    await writeReport(c, run.output ?? "");
+    return [];
+  }
+  const a = parseAnswer(run.output ?? "");
+  if (a.problems.length)
+    return a.problems;
+  if (a.changes.length === 0)
+    return ["the answer changes no files"];
+  for (const p of await applyChanges(c.worktree, a.changes))
+    if (!c.record.changed.includes(p))
+      c.record.changed.push(p);
+  await writeReport(c, a.report);
+  return [];
+}
+async function writeReport(c, text) {
+  await writeFileAtomic(join5(changeFolder(c.root, c.t.change.id), `tasks/${c.t.task.id}/report.md`), `# Task ${c.t.task.id}: ${c.t.task.title}
+
+${text.trim() || "No report was given."}
+`);
+}
+async function buildAndFix(c, runId) {
+  let a = await build(c, runId);
+  if (!a) {
+    c.record.notes.push(`${c.t.repo.id} has no build command in repos.manifest.yaml, so the change wasn't built or tested.`);
+    c.record.state = "unverified";
+    return;
+  }
+  let fixes = 0;
+  while (!a.passed && fixes < c.maxFix && c.runtime.kind !== "hand-off") {
+    fixes++;
+    const log = await import("node:fs/promises").then((fs) => fs.readFile(join5(c.root, a.log), "utf8"));
+    const fix = await aiStep(c, { command: a.command, text: log, attempt: fixes });
+    if (fix.state !== "validated") {
+      c.record.notes.push(`Fix round ${fixes} failed: ${fix.errors.join("; ") || fix.state}.`);
+      break;
+    }
+    const problems = await applyAnswer(c, fix);
+    if (problems.length) {
+      c.record.notes.push(`Fix round ${fixes} was not applied: ${problems.join("; ")}.`);
+      break;
+    }
+    a = await build(c, runId, fix.runId);
+  }
+  if (!a.passed) {
+    c.record.state = "needs-person";
+    c.record.notes.push(`The build still fails after ${fixes} fix round${fixes === 1 ? "" : "s"}; a person takes over in ${c.record.worktree}. See ${a.log}.`);
+    return;
+  }
+  c.record.state = "built";
+}
+async function commit(c, runId) {
+  await c.git(["add", "-A", "--", "."], c.worktree);
+  const staged = (await c.git(["diff", "--cached", "--name-only"], c.worktree)).stdout.trim();
+  if (!staged) {
+    c.record.notes.push("Nothing to commit.");
+    return;
+  }
+  await c.git([
+    "commit",
+    "-q",
+    "-m",
+    `${c.t.task.title} (task ${c.t.task.id} of ${c.t.change.id})`,
+    "-m",
+    `Atticus-Change: ${c.t.change.id}
+Atticus-Task: ${c.t.task.id}
+Atticus-Run: ${runId}
+Requested-By: ${c.record.by}`
+  ], c.worktree);
+  c.record.commit = (await c.git(["rev-parse", "HEAD"], c.worktree)).stdout.trim();
+}
+async function openPr(c) {
+  if (c.record.state !== "built") {
+    c.record.notes.push(c.record.state === "unverified" ? "No PR: a pull request needs a passing build, and this repo has no build command." : "No PR: the build doesn't pass.");
+    if (c.record.state === "unverified")
+      c.record.state = "needs-person";
+    return;
+  }
+  const approval = requireApproval("git-host", c.approval);
+  if (!c.gitHost) {
+    c.record.state = "needs-person";
+    c.record.notes.push(`No Git host is connected (runtime.yaml adapters.gitHost): push ${c.record.branch} and open the PR into ${changeBranch(c.t.change.id)} by hand, then record it.`);
+    return;
+  }
+  const base = changeBranch(c.t.change.id);
+  const info = await c.gitHost.getRepo(c.t.repo.id);
+  for (const b of [c.record.branch, base])
+    if (info.protectedBranches.includes(b))
+      throw new TaskRunError("refused", `${b} is protected in ${c.t.repo.id}; Run with AI never pushes to or opens a PR into a protected branch.`);
+  if (base === info.defaultBranch)
+    throw new TaskRunError("refused", `${base} is ${c.t.repo.id}'s default branch; task PRs go into the change branch.`);
+  await c.git([
+    "push",
+    "-q",
+    "origin",
+    `refs/heads/${base}:refs/heads/${base}`,
+    `refs/heads/${c.record.branch}:refs/heads/${c.record.branch}`
+  ], c.worktree);
+  try {
+    const pr = await c.gitHost.createPullRequest({
+      repo: c.t.repo.id,
+      head: c.record.branch,
+      base,
+      title: `${c.t.task.title} (task ${c.t.task.id} of ${c.t.change.id})`,
+      body: [
+        `Task ${c.t.task.id} of change ${c.t.change.id}, drafted with Run with AI (${c.record.runtime}) and requested by ${c.record.by}.`,
+        "",
+        `Build: ${c.record.attempts.at(-1)?.command ?? "none"} passed after ${c.record.attempts.length} attempt${c.record.attempts.length === 1 ? "" : "s"}.`,
+        `Files: ${c.record.changed.join(", ") || "none"}.`,
+        "",
+        "A person reviews and merges this PR; Atticus never merges or deploys."
+      ].join("\n")
+    }, approval);
+    c.record.pr = { number: pr.number, url: pr.url };
+    c.record.state = "pr-open";
+  } catch (e) {
+    if (e instanceof AdapterError) {
+      c.record.state = "needs-person";
+      c.record.notes.push(`The PR couldn't be opened: ${e.message}`);
+      return;
+    }
+    throw e;
+  }
+}
+async function finish(c, run) {
+  if (c.record.level === "plan") {
+    if (c.runtime.kind !== "hand-off")
+      await writeFileAtomic(join5(changeFolder(c.root, c.t.change.id), run.request.outputPath), `${(run.output ?? "").trim()}
+`);
+    c.record.state = "planned";
+  } else {
+    if (c.runtime.kind !== "hand-off") {
+      const problems = await applyAnswer(c, run);
+      if (problems.length) {
+        c.record.state = "failed";
+        c.record.notes.push(`The answer was not applied: ${problems.join("; ")}.`);
+        return done(c);
+      }
+    }
+    await buildAndFix(c, run.runId);
+    if (c.record.state === "built" || c.record.state === "unverified")
+      await commit(c, run.runId);
+    await conformAfterBuild(c);
+    if (c.record.level === "pr")
+      await openPr(c);
+  }
+  return done(c);
+}
+async function done(c) {
+  delete c.record.waiting;
+  c.record.finishedAt = stamp2(c.now());
+  return saveTaskRun(c.root, c.record);
+}
+async function runTask(root, changeId, taskId, o) {
+  const now = o.now ?? (() => /* @__PURE__ */ new Date());
+  const git = o.git ?? createGit();
+  let t = await loadTask(root, changeId, taskId);
+  const rt = t.ctx.orgPack.runtime;
+  const level = o.level ?? AUTONOMY[rt.autonomy.default];
+  const cap = rt.autonomy.capPerRepo[t.repo.id];
+  if (cap && LEVEL_RANK[level] > LEVEL_RANK[AUTONOMY[cap]])
+    throw new TaskRunError("refused", `${t.repo.id} allows Run with AI up to ${cap} (runtime.yaml autonomy.capPerRepo); ask for a lower level.`);
+  if (level === "pr") {
+    try {
+      requireApproval("git-host", o.approval);
+    } catch {
+      throw new TaskRunError("refused", "The pr level pushes the task branch and opens a PR, which needs your approval: run it again with --approve.");
+    }
+  }
+  const engine = buildEngineFor(t.ctx.orgPack, t.repo.id);
+  const changeDir = await changeWorktree(root, t.change.id, t.repo.id);
+  const handed = engine === "speckit" ? `specs/${t.task.id}/plan.md` : `.atticus/tasks/${t.task.id}.md`;
+  const notes = [];
+  if (!existsSync2(join5(changeDir, handed))) {
+    const h = await handDown(root, t.change.id, t.task.id, { git });
+    notes.push(`Handed the task down first (${h.feature} in ${h.repo}${h.commit ? `, commit ${h.commit.slice(0, 12)}` : ""}).`);
+    t = await loadTask(root, changeId, taskId);
+  }
+  const wt = await openTaskWorktree(root, t.change.id, t.task.id, t.repo.id, git);
+  const runtime = o.runtime ?? await createRuntime(t.ctx.orgPack, {
+    root,
+    ...o.mode ? { mode: o.mode } : {},
+    ...o.replayDir ? { replayDir: o.replayDir } : {},
+    now,
+    ...o.runtimeOptions,
+    headless: {
+      ...o.runtimeOptions?.headless,
+      invocation: () => ({
+        cwd: wt.path,
+        permissionMode: level === "plan" ? "plan" : "acceptEdits",
+        ...engine === "speckit" ? { env: { SPECIFY_FEATURE_DIRECTORY: `specs/${t.task.id}` } } : {}
+      })
+    }
+  });
+  let gitHost = o.gitHost;
+  if (!gitHost && level === "pr")
+    gitHost = gitHostOf(root, t);
+  const record = {
+    schemaVersion: 1,
+    change: t.change.id,
+    task: t.task.id,
+    repo: t.repo.id,
+    level,
+    runtime: runtime.kind,
+    engine,
+    by: o.by,
+    branch: wt.branch,
+    worktree: toRepoRelative(root, wt.path),
+    state: "failed",
+    runs: [],
+    attempts: [],
+    changed: [],
+    startedAt: stamp2(now()),
+    notes
+  };
+  const c = {
+    root,
+    t,
+    record,
+    worktree: wt.path,
+    runtime,
+    commands: o.commands ?? shellCommandRunner(),
+    git,
+    ...gitHost ? { gitHost } : {},
+    ...o.approval ? { approval: o.approval } : {},
+    now,
+    maxFix: rt.autonomy.maxFixRounds
+  };
+  const run = await aiStep(c);
+  if (run.state === "waiting") {
+    record.state = "waiting";
+    record.waiting = run.runId;
+    return saveTaskRun(root, record);
+  }
+  if (run.state !== "validated") {
+    record.notes.push(`The AI run ended ${run.state}: ${run.errors.join("; ") || "no reason given"}.`);
+    return done(c);
+  }
+  return finish(c, run);
+}
+async function completeTaskHandoff(root, runId, o = {}) {
+  const record = await findWaitingTaskRun(root, runId);
+  if (!record)
+    throw new TaskRunError("not-found", `No task run is waiting on ${runId}.`);
+  const now = o.now ?? (() => /* @__PURE__ */ new Date());
+  const git = o.git ?? createGit();
+  const t = await loadTask(root, record.change, record.task);
+  const rt = t.ctx.orgPack.runtime;
+  const commands = o.commands ?? shellCommandRunner();
+  let gitHost = o.gitHost;
+  if (!gitHost && record.level === "pr")
+    gitHost = gitHostOf(root, t);
+  const c = {
+    root,
+    t,
+    record,
+    worktree: join5(root, record.worktree),
+    runtime: void 0,
+    commands,
+    git,
+    ...gitHost ? { gitHost } : {},
+    ...o.approval ? { approval: o.approval } : {},
+    now,
+    maxFix: rt.autonomy.maxFixRounds
+  };
+  let attempt;
+  const handoff = new HandoffRuntime({
+    root,
+    now,
+    validate: async (file) => {
+      const text = await import("node:fs/promises").then((fs) => fs.readFile(file, "utf8"));
+      if (!text.trim())
+        return [`${file.slice(root.length + 1)} is empty`];
+      if (record.level === "plan")
+        return [];
+      attempt = await build(c, runId);
+      if (!attempt)
+        return [];
+      return attempt.passed ? [] : [`${attempt.command} failed; see ${attempt.log}`];
+    }
+  });
+  c.runtime = handoff;
+  const run = await handoff.done(runId);
+  await summarise(c, run);
+  if (run.state === "validated") {
+    if (record.level === "plan")
+      record.state = "planned";
+    else {
+      record.state = attempt ? "built" : "unverified";
+      if (!attempt)
+        record.notes.push(`${t.repo.id} has no build command in repos.manifest.yaml, so the change wasn't built or tested.`);
+      const changed = await git(["status", "--porcelain"], c.worktree);
+      for (const l of changed.stdout.split("\n").filter(Boolean)) {
+        const p = l.slice(3).trim();
+        if (!record.changed.includes(p))
+          record.changed.push(p);
+      }
+      await commit(c, runId);
+      await conformAfterBuild(c);
+      if (record.level === "pr")
+        await openPr(c);
+    }
+    return done(c);
+  }
+  const builds = record.attempts.length;
+  if (attempt && !attempt.passed && builds <= c.maxFix) {
+    await handoff.retry(runId);
+    await handoff.run(runId);
+    record.notes.push(`Build attempt ${builds} failed; the run is waiting for a fix (${run.errors.join("; ")}).`);
+    return saveTaskRun(root, record);
+  }
+  record.state = attempt && !attempt.passed ? "needs-person" : "failed";
+  record.notes.push(attempt && !attempt.passed ? `The build still fails after ${builds} attempts; a person takes over in ${record.worktree}.` : `The hand-off failed: ${run.errors.join("; ")}.`);
+  return done(c);
+}
+async function isTaskRun(root, runId) {
+  return await findWaitingTaskRun(root, runId) !== void 0;
+}
+
+export {
+  FILE_FORMAT,
+  refusedPath,
+  parseAnswer,
+  applyChanges,
+  shellCommandRunner,
+  TaskRunState,
+  RunLevel,
+  BuildAttempt,
+  TaskRunRecord,
+  taskDir,
+  saveTaskRun,
+  readTaskRun,
+  saveRunSummary,
+  findWaitingTaskRun,
+  TASK_RUNNER,
+  taskRunnerAgent,
+  taskPack,
+  CONFORM_GATE,
+  CONFORM_DIR,
+  ConformError,
+  conformScanDir,
+  conformFindingId,
+  conformFindings,
+  readConformResults,
+  conformChange,
+  conformanceOf,
+  conformAfterBuild,
+  TaskRunError,
+  runTask,
+  completeTaskHandoff,
+  isTaskRun
+};