@hasna/loops 0.3.12 → 0.3.14

package/dist/cli/index.js

@@ -370,6 +370,35 @@ function validateTarget(value, label) {
       if (value.provider !== "codewith")
         throw new Error(`${label}.authProfile is currently supported only for provider codewith`);
     }
+    if (value.variant !== undefined)
+      assertString(value.variant, `${label}.variant`);
+    if (value.permissionMode !== undefined) {
+      assertString(value.permissionMode, `${label}.permissionMode`);
+      const permissionModes = ["default", "plan", "auto", "bypass"];
+      if (!permissionModes.includes(value.permissionMode)) {
+        throw new Error(`${label}.permissionMode must be one of ${permissionModes.join(", ")}`);
+      }
+      if (value.permissionMode === "plan" && !["claude", "cursor"].includes(value.provider)) {
+        throw new Error(`${label}.permissionMode plan is currently supported only for provider claude or cursor`);
+      }
+      if (value.permissionMode === "auto" && value.provider !== "claude") {
+        throw new Error(`${label}.permissionMode auto is currently supported only for provider claude`);
+      }
+    }
+    if (value.sandbox !== undefined) {
+      assertString(value.sandbox, `${label}.sandbox`);
+      const codexLike = ["read-only", "workspace-write", "danger-full-access"];
+      const cursorLike = ["enabled", "disabled"];
+      if (["codewith", "codex"].includes(value.provider)) {
+        if (!codexLike.includes(value.sandbox))
+          throw new Error(`${label}.sandbox must be one of ${codexLike.join(", ")}`);
+      } else if (value.provider === "cursor") {
+        if (!cursorLike.includes(value.sandbox))
+          throw new Error(`${label}.sandbox must be one of ${cursorLike.join(", ")}`);
+      } else {
+        throw new Error(`${label}.sandbox is currently supported only for provider codewith, codex, or cursor`);
+      }
+    }
     return value;
   }
   throw new Error(`${label}.type must be command or agent`);
@@ -2045,6 +2074,7 @@ class Store {
 }
 
 // src/cli/index.ts
+import { createHash } from "crypto";
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 import { Command } from "commander";
 
@@ -2468,7 +2498,7 @@ function providerCommand(provider) {
     case "claude":
       return "claude";
     case "cursor":
-      return "cursor-agent";
+      return "sh";
     case "codewith":
       return "codewith";
     case "aicopilot":
@@ -2479,22 +2509,107 @@ function providerCommand(provider) {
       return "codex";
   }
 }
+function codewithLikeSandbox(target) {
+  const sandbox = target.sandbox ?? (target.permissionMode === "bypass" ? "danger-full-access" : "workspace-write");
+  if (sandbox !== "read-only" && sandbox !== "workspace-write" && sandbox !== "danger-full-access") {
+    throw new Error(`${target.provider} sandbox must be read-only, workspace-write, or danger-full-access`);
+  }
+  return sandbox;
+}
+function configStringValue(value) {
+  return JSON.stringify(value);
+}
+function assertStringOption(value, label) {
+  if (value !== undefined && typeof value !== "string")
+    throw new Error(`${label} must be a string`);
+}
+function assertSupportedAgentOptions(target) {
+  assertStringOption(target.variant, `${target.provider}.variant`);
+  assertStringOption(target.model, `${target.provider}.model`);
+  assertStringOption(target.agent, `${target.provider}.agent`);
+  assertStringOption(target.authProfile, `${target.provider}.authProfile`);
+  if (target.authProfile !== undefined && target.provider !== "codewith") {
+    throw new Error(`${target.provider}.authProfile is supported only for codewith`);
+  }
+  if (target.permissionMode && !["default", "plan", "auto", "bypass"].includes(target.permissionMode)) {
+    throw new Error(`${target.provider}.permissionMode must be default, plan, auto, or bypass`);
+  }
+  if (target.sandbox && !["read-only", "workspace-write", "danger-full-access", "enabled", "disabled"].includes(target.sandbox)) {
+    throw new Error(`${target.provider}.sandbox is not supported: ${target.sandbox}`);
+  }
+  if (["codewith", "codex"].includes(target.provider)) {
+    if (target.permissionMode && !["default", "bypass"].includes(target.permissionMode)) {
+      throw new Error(`${target.provider}.permissionMode supports only default or bypass`);
+    }
+    if (target.sandbox)
+      codewithLikeSandbox(target);
+    return;
+  }
+  if (target.provider === "claude") {
+    if (target.sandbox !== undefined)
+      throw new Error("claude.sandbox is not supported");
+    return;
+  }
+  if (target.provider === "cursor") {
+    if (target.permissionMode === "auto")
+      throw new Error("cursor.permissionMode auto is not supported; use provider-specific extraArgs for Cursor auto-review");
+    if (target.sandbox !== undefined && target.sandbox !== "enabled" && target.sandbox !== "disabled") {
+      throw new Error("cursor.sandbox must be enabled or disabled");
+    }
+    return;
+  }
+  if (target.permissionMode && !["default", "bypass"].includes(target.permissionMode)) {
+    throw new Error(`${target.provider}.permissionMode supports only default or bypass`);
+  }
+  if (target.sandbox !== undefined)
+    throw new Error(`${target.provider}.sandbox is not supported`);
+}
 function agentArgs(target) {
+  assertSupportedAgentOptions(target);
   const isolation = target.configIsolation ?? "safe";
+  const permissionMode = target.permissionMode ?? "default";
   const args = [];
   switch (target.provider) {
     case "claude":
       if (isolation === "safe")
         args.push("--safe-mode", "--setting-sources", "local", "--no-session-persistence");
+      if (permissionMode !== "default") {
+        const mode = permissionMode === "bypass" ? "bypassPermissions" : permissionMode === "plan" || permissionMode === "auto" ? permissionMode : undefined;
+        if (mode)
+          args.push("--permission-mode", mode);
+      }
       args.push("-p", "--output-format", "json");
       if (target.model)
         args.push("--model", target.model);
+      if (target.variant)
+        args.push("--effort", target.variant);
       if (target.agent)
         args.push("--agent", target.agent);
       args.push(...target.extraArgs ?? []);
       return args;
     case "cursor":
-      args.push("agent", "-p");
+      args.push("-c", [
+        "set -eu",
+        "if command -v cursor >/dev/null 2>&1; then",
+        '  exec cursor agent "$@"',
+        "elif command -v agent >/dev/null 2>&1; then",
+        '  exec agent "$@"',
+        "else",
+        "  echo 'Executable not found in PATH: cursor agent or agent' >&2",
+        "  exit 127",
+        "fi"
+      ].join(`
+`), "openloops-cursor", "-p");
+      if (permissionMode === "plan")
+        args.push("--mode", "plan");
+      if (permissionMode === "bypass")
+        args.push("--force");
+      const cursorSandbox = target.sandbox ?? (isolation === "safe" ? "enabled" : undefined);
+      if (cursorSandbox) {
+        if (cursorSandbox !== "enabled" && cursorSandbox !== "disabled")
+          throw new Error("cursor sandbox must be enabled or disabled");
+        args.push("--sandbox", cursorSandbox);
+      }
       if (target.model)
         args.push("--model", target.model);
       if (target.agent)
@@ -2502,7 +2617,10 @@ function agentArgs(target) {
       args.push(...target.extraArgs ?? []);
       return args;
     case "codewith":
-      args.push(...target.authProfile ? ["--auth-profile", target.authProfile] : [], "--ask-for-approval", "never", "exec", "--json", "--ephemeral", "--sandbox", "workspace-write", "--skip-git-repo-check");
+      args.push(...target.authProfile ? ["--auth-profile", target.authProfile] : []);
+      if (target.variant)
+        args.push("-c", `model_reasoning_effort=${configStringValue(target.variant)}`);
+      args.push("--ask-for-approval", "never", "exec", "--json", "--ephemeral", "--sandbox", codewithLikeSandbox(target), "--skip-git-repo-check");
       if (isolation === "safe")
         args.push("--ignore-rules");
       if (target.cwd)
@@ -2514,7 +2632,9 @@ function agentArgs(target) {
       args.push(...target.extraArgs ?? []);
       return args;
     case "codex":
-      args.push("exec", "--json", "--ephemeral", "--ask-for-approval", "never", "--sandbox", "workspace-write");
+      if (target.variant)
+        args.push("-c", `model_reasoning_effort=${configStringValue(target.variant)}`);
+      args.push("exec", "--json", "--ephemeral", "--ask-for-approval", "never", "--sandbox", codewithLikeSandbox(target));
       if (isolation === "safe")
         args.push("--ignore-rules");
       if (target.cwd)
@@ -2527,10 +2647,14 @@ function agentArgs(target) {
       args.push("run", "--format", "json");
       if (isolation === "safe")
         args.push("--pure");
+      if (permissionMode === "bypass")
+        args.push("--dangerously-skip-permissions");
       if (target.cwd)
         args.push("--dir", target.cwd);
       if (target.model)
         args.push("--model", target.model);
+      if (target.variant)
+        args.push("--variant", target.variant);
       if (target.agent)
         args.push("--agent", target.agent);
       args.push(...target.extraArgs ?? []);
@@ -2539,10 +2663,14 @@ function agentArgs(target) {
       args.push("run", "--format", "json");
       if (isolation === "safe")
         args.push("--pure");
+      if (permissionMode === "bypass")
+        args.push("--dangerously-skip-permissions");
       if (target.cwd)
         args.push("--dir", target.cwd);
       if (target.model)
         args.push("--model", target.model);
+      if (target.variant)
+        args.push("--variant", target.variant);
       if (target.agent)
         args.push("--agent", target.agent);
       args.push(...target.extraArgs ?? []);
@@ -2571,6 +2699,7 @@ function commandSpec(target) {
     timeoutMs: agentTarget.timeoutMs ?? DEFAULT_TIMEOUT_MS,
     account: agentTarget.account,
     accountTool: agentTarget.account?.tool ?? accountToolForProvider(agentTarget.provider),
+    preflightAnyOf: agentTarget.provider === "cursor" ? ["cursor", "agent"] : undefined,
     stdin: agentTarget.prompt
   };
 }
@@ -2638,11 +2767,15 @@ function remoteScript(spec, metadata) {
 `;
 }
 function remotePreflightScript(spec, metadata) {
-  return [
+  const lines = [
     ...remoteBootstrapLines(spec, metadata),
     "command -v bash >/dev/null 2>&1",
     `command -v ${shellQuote(spec.shell ? "sh" : spec.command)} >/dev/null 2>&1`
-  ].join(`
+  ];
+  if (spec.preflightAnyOf?.length) {
+    lines.push(`if ! ${spec.preflightAnyOf.map((command) => `command -v ${shellQuote(command)} >/dev/null 2>&1`).join(" && ! ")}; then`, `  echo 'none of required executables found: ${spec.preflightAnyOf.join(", ")}' >&2`, "  exit 127", "fi");
+  }
+  return lines.join(`
 `);
 }
 function transportEnv(opts) {
@@ -2795,6 +2928,9 @@ function preflightTarget(target, metadata = {}, opts = {}) {
   if (!spec.shell && !executableExists(spec.command, env)) {
     throw new Error(commandNotFoundMessage(spec.command, env));
   }
+  if (spec.preflightAnyOf?.length && !spec.preflightAnyOf.some((command) => executableExists(command, env))) {
+    throw new Error(`none of required executables found: ${spec.preflightAnyOf.join(", ")}`);
+  }
   return {
     command: spec.command,
     accountProfile: spec.account?.profile,
@@ -2825,6 +2961,17 @@ async function executeTarget(target, metadata = {}, opts = {}) {
       durationMs: 0
     };
   }
+  if (spec.preflightAnyOf?.length && !spec.preflightAnyOf.some((command) => executableExists(command, env))) {
+    return {
+      status: "failed",
+      stdout,
+      stderr,
+      error: `none of required executables found: ${spec.preflightAnyOf.join(", ")}`,
+      startedAt,
+      finishedAt: nowIso(),
+      durationMs: 0
+    };
+  }
   const child = spawn(spec.command, spec.args, {
     cwd: spec.cwd,
     env,
@@ -4241,17 +4388,35 @@ import { spawnSync as spawnSync4 } from "child_process";
 import { accessSync as accessSync2, constants as constants2 } from "fs";
 var PROVIDER_COMMANDS = [
   "claude",
-  "cursor-agent",
+  "cursor agent",
   "codewith",
   "aicopilot",
   "opencode",
   "codex"
 ];
 function hasCommand(command) {
+  if (command === "cursor agent") {
+    return hasCommand("cursor") || hasCommand("agent");
+  }
   const result = spawnSync4("sh", ["-c", 'command -v "$1" >/dev/null', "sh", command], { stdio: "ignore" });
   return (result.status ?? 1) === 0;
 }
 function commandVersion(command) {
+  if (command === "cursor agent") {
+    const cursorResult = spawnSync4("cursor", ["agent", "--version"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if ((cursorResult.status ?? 1) === 0)
+      return (cursorResult.stdout || cursorResult.stderr).trim().split(/\r?\n/)[0];
+    const agentResult = spawnSync4("agent", ["--version"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if ((agentResult.status ?? 1) === 0)
+      return (agentResult.stdout || agentResult.stderr).trim().split(/\r?\n/)[0];
+    return;
+  }
   const result = spawnSync4(command, ["--version"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
@@ -4330,7 +4495,7 @@ function runDoctor(store) {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.3.12",
+  version: "0.3.14",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -4394,6 +4559,7 @@ var package_default = {
     bun: ">=1.0.0"
   },
   dependencies: {
+    "@hasna/events": "^0.1.9",
     "@hasna/machines": "0.0.49",
     "@openrouter/ai-sdk-provider": "2.9.1",
     ai: "6.0.204",
@@ -4417,6 +4583,242 @@ function packageVersion() {
   return package_default.version;
 }
 
+// src/lib/templates.ts
+var TODOS_TASK_WORKER_VERIFIER_TEMPLATE_ID = "todos-task-worker-verifier";
+var EVENT_WORKER_VERIFIER_TEMPLATE_ID = "event-worker-verifier";
+var TEMPLATE_SUMMARIES = [
+  {
+    id: TODOS_TASK_WORKER_VERIFIER_TEMPLATE_ID,
+    name: "Todos Task Worker + Verifier",
+    description: "Create a one-shot workflow for a todos task: one agent performs the task, then a fresh verifier agent audits the result and records follow-up tasks or completion evidence.",
+    kind: "workflow",
+    variables: [
+      { name: "taskId", required: true, description: "Todos task id to execute." },
+      { name: "taskTitle", description: "Human-readable task title." },
+      { name: "projectPath", required: true, description: "Repository or project working directory." },
+      { name: "provider", default: "codewith", description: "Agent provider: codewith, claude, cursor, opencode, aicopilot, or codex." },
+      { name: "authProfile", description: "Provider-native auth profile, currently Codewith." },
+      { name: "model", description: "Provider model." },
+      { name: "variant", description: "Provider reasoning/model effort variant." },
+      { name: "permissionMode", default: "bypass", description: "Provider permission mode: default, plan, auto, or bypass." },
+      { name: "sandbox", default: "danger-full-access", description: "Provider sandbox mode." }
+    ]
+  },
+  {
+    id: EVENT_WORKER_VERIFIER_TEMPLATE_ID,
+    name: "Hasna Event Worker + Verifier",
+    description: "Create a one-shot workflow for a generic Hasna event: one agent handles the event, then a fresh verifier agent audits the result and records evidence or follow-up tasks.",
+    kind: "workflow",
+    variables: [
+      { name: "eventId", required: true, description: "Hasna event id." },
+      { name: "eventType", required: true, description: "Hasna event type." },
+      { name: "eventSource", required: true, description: "Hasna event source." },
+      { name: "eventJson", required: true, description: "Full event envelope JSON." },
+      { name: "projectPath", required: true, description: "Repository or project working directory." },
+      { name: "provider", default: "codewith", description: "Agent provider: codewith, claude, cursor, opencode, aicopilot, or codex." },
+      { name: "authProfile", description: "Provider-native auth profile, currently Codewith." },
+      { name: "model", description: "Provider model." },
+      { name: "variant", description: "Provider reasoning/model effort variant." },
+      { name: "permissionMode", default: "bypass", description: "Provider permission mode: default, plan, auto, or bypass." },
+      { name: "sandbox", default: "danger-full-access", description: "Provider sandbox mode." }
+    ]
+  }
+];
+function compactJson(value) {
+  return JSON.stringify(value);
+}
+function taskLabel(input) {
+  const head = input.taskTitle?.trim() || input.taskId;
+  return head.length > 160 ? `${head.slice(0, 157)}...` : head;
+}
+function agentTarget(input, prompt) {
+  const provider = input.provider ?? "codewith";
+  const sandbox = input.sandbox ?? (provider === "codewith" || provider === "codex" ? "danger-full-access" : provider === "cursor" ? "disabled" : undefined);
+  return {
+    type: "agent",
+    provider,
+    prompt,
+    cwd: input.projectPath,
+    model: input.model,
+    variant: input.variant,
+    agent: input.agent,
+    authProfile: provider === "codewith" ? input.authProfile : undefined,
+    configIsolation: "safe",
+    permissionMode: input.permissionMode ?? "bypass",
+    sandbox,
+    account: input.account,
+    timeoutMs: 45 * 60000
+  };
+}
+function listLoopTemplates() {
+  return TEMPLATE_SUMMARIES.map((template) => structuredClone(template));
+}
+function getLoopTemplate(id) {
+  return listLoopTemplates().find((template) => template.id === id || template.name === id);
+}
+function renderTodosTaskWorkerVerifierWorkflow(input) {
+  if (!input.taskId?.trim())
+    throw new Error("taskId is required");
+  if (!input.projectPath?.trim())
+    throw new Error("projectPath is required");
+  const taskContext = {
+    taskId: input.taskId,
+    taskTitle: input.taskTitle,
+    taskDescription: input.taskDescription,
+    eventId: input.eventId,
+    eventType: input.eventType,
+    projectPath: input.projectPath
+  };
+  const workerPrompt = [
+    `/goal Complete todos task ${input.taskId} in ${input.projectPath}.`,
+    "",
+    "You are the worker agent for a task-triggered OpenLoops workflow.",
+    "Investigate first before changing files. Use the todos CLI as the source of truth for the task.",
+    "Claim/start the task if appropriate, inspect the repository/project state, implement only the task scope, run focused validation, preserve unrelated user changes, and update the task with comments, evidence, changed files, commits, and blockers.",
+    "Do not mark the task complete unless the work is genuinely done and validated.",
+    "",
+    `Task context JSON: ${compactJson(taskContext)}`
+  ].join(`
+`);
+  const verifierPrompt = [
+    `/goal Verify todos task ${input.taskId} after the worker step.`,
+    "",
+    "You are the verifier agent for a task-triggered OpenLoops workflow.",
+    "Use fresh context. Inspect the task, repository state, commits, tests, and worker evidence. Act as an adversarial reviewer focused on correctness, regressions, missing tests, security, and incomplete requirements.",
+    "If the work is valid, record verification evidence in todos and mark/leave the task in the correct completed state according to the todos CLI. If it is not valid, add precise follow-up tasks or comments and leave the original task open or blocked with clear evidence.",
+    "Do not make broad unrelated changes. Only apply tiny verification fixes when they are necessary and low risk; otherwise create follow-up tasks.",
+    "",
+    `Task context JSON: ${compactJson(taskContext)}`
+  ].join(`
+`);
+  return {
+    name: `todos-task-${input.taskId.slice(0, 8)}-worker-verifier`,
+    description: `Task-triggered worker/verifier workflow for ${taskLabel(input)}`,
+    version: 1,
+    steps: [
+      {
+        id: "worker",
+        name: "Worker",
+        description: "Implement the todos task and record evidence.",
+        target: agentTarget(input, workerPrompt),
+        timeoutMs: 45 * 60000
+      },
+      {
+        id: "verifier",
+        name: "Verifier",
+        description: "Adversarially verify worker output and update todos.",
+        dependsOn: ["worker"],
+        target: agentTarget(input, verifierPrompt),
+        timeoutMs: 30 * 60000
+      }
+    ]
+  };
+}
+function renderEventWorkerVerifierWorkflow(input) {
+  if (!input.eventId?.trim())
+    throw new Error("eventId is required");
+  if (!input.eventType?.trim())
+    throw new Error("eventType is required");
+  if (!input.eventSource?.trim())
+    throw new Error("eventSource is required");
+  if (!input.eventJson?.trim())
+    throw new Error("eventJson is required");
+  if (!input.projectPath?.trim())
+    throw new Error("projectPath is required");
+  const eventContext = {
+    eventId: input.eventId,
+    eventType: input.eventType,
+    eventSource: input.eventSource,
+    eventSubject: input.eventSubject,
+    eventMessage: input.eventMessage,
+    projectPath: input.projectPath
+  };
+  const workerPrompt = [
+    `/goal Handle Hasna event ${input.eventSource}/${input.eventType} (${input.eventId}) in ${input.projectPath}.`,
+    "",
+    "You are the worker agent for an event-triggered OpenLoops workflow.",
+    "Investigate first before changing files. Read the full event envelope and decide the narrow action required by that event. Preserve unrelated user changes and update the relevant local CLI/task/knowledge system with evidence, changed files, commits, and blockers.",
+    "If the event is informational or does not require action, record that finding and stop without making changes.",
+    "",
+    `Event context JSON: ${compactJson(eventContext)}`,
+    `Full event envelope JSON: ${input.eventJson}`
+  ].join(`
+`);
+  const verifierPrompt = [
+    `/goal Verify handling of Hasna event ${input.eventSource}/${input.eventType} (${input.eventId}).`,
+    "",
+    "You are the verifier agent for an event-triggered OpenLoops workflow.",
+    "Use fresh context. Inspect the event, repository/project state, worker evidence, tests, and any created tasks or notes. Act as an adversarial reviewer focused on correctness, regressions, security, missing evidence, and incomplete requirements.",
+    "If the work is valid, record verification evidence in the relevant local system. If it is not valid, add precise follow-up tasks/comments and leave the event handling state open or blocked with clear evidence.",
+    "",
+    `Event context JSON: ${compactJson(eventContext)}`,
+    `Full event envelope JSON: ${input.eventJson}`
+  ].join(`
+`);
+  return {
+    name: `event-${input.eventSource}-${input.eventType}-${input.eventId.slice(0, 8)}-worker-verifier`.replace(/[^a-zA-Z0-9._:-]+/g, "-"),
+    description: `Event-triggered worker/verifier workflow for ${input.eventSource}/${input.eventType}`,
+    version: 1,
+    steps: [
+      {
+        id: "worker",
+        name: "Worker",
+        description: "Handle the Hasna event and record evidence.",
+        target: agentTarget(input, workerPrompt),
+        timeoutMs: 45 * 60000
+      },
+      {
+        id: "verifier",
+        name: "Verifier",
+        description: "Adversarially verify event handling.",
+        dependsOn: ["worker"],
+        target: agentTarget(input, verifierPrompt),
+        timeoutMs: 30 * 60000
+      }
+    ]
+  };
+}
+function renderLoopTemplate(id, values) {
+  if (id === TODOS_TASK_WORKER_VERIFIER_TEMPLATE_ID) {
+    return renderTodosTaskWorkerVerifierWorkflow({
+      taskId: values.taskId ?? "",
+      taskTitle: values.taskTitle,
+      taskDescription: values.taskDescription,
+      projectPath: values.projectPath ?? values.cwd ?? process.cwd(),
+      provider: values.provider,
+      authProfile: values.authProfile,
+      account: values.account ? { profile: values.account, tool: values.accountTool } : undefined,
+      model: values.model,
+      variant: values.variant,
+      agent: values.agent,
+      permissionMode: values.permissionMode,
+      sandbox: values.sandbox,
+      eventId: values.eventId,
+      eventType: values.eventType
+    });
+  }
+  if (id === EVENT_WORKER_VERIFIER_TEMPLATE_ID) {
+    return renderEventWorkerVerifierWorkflow({
+      eventId: values.eventId ?? "",
+      eventType: values.eventType ?? "",
+      eventSource: values.eventSource ?? "",
+      eventSubject: values.eventSubject,
+      eventMessage: values.eventMessage,
+      eventJson: values.eventJson ?? "",
+      projectPath: values.projectPath ?? values.cwd ?? process.cwd(),
+      provider: values.provider,
+      authProfile: values.authProfile,
+      account: values.account ? { profile: values.account, tool: values.accountTool } : undefined,
+      model: values.model,
+      variant: values.variant,
+      agent: values.agent,
+      permissionMode: values.permissionMode,
+      sandbox: values.sandbox
+    });
+  }
+  throw new Error(`unknown template: ${id}`);
+}
+
 // src/cli/index.ts
 var program = new Command;
 program.name("loops").description("Persistent local loops for commands and headless coding agents").version(packageVersion());
@@ -4535,6 +4937,78 @@ function accountFromOpts(opts) {
     throw new Error("--account-tool requires --account");
   return opts.account ? { profile: opts.account, tool: opts.accountTool } : undefined;
 }
+function parseVars(values) {
+  const vars = {};
+  for (const value of values ?? []) {
+    const index = value.indexOf("=");
+    if (index <= 0)
+      throw new Error(`invalid --var value, expected key=value: ${value}`);
+    vars[value.slice(0, index)] = value.slice(index + 1);
+  }
+  return vars;
+}
+function collectValues(value, previous = []) {
+  previous.push(value);
+  return previous;
+}
+function eventData(event) {
+  const data = event.data;
+  if (data && typeof data === "object" && !Array.isArray(data))
+    return data;
+  return {};
+}
+function eventMetadata(event) {
+  const metadata = event.metadata;
+  if (metadata && typeof metadata === "object" && !Array.isArray(metadata))
+    return metadata;
+  return {};
+}
+function stringField(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function slugSegment(value, fallback = "event") {
+  return value.toLowerCase().replace(/[^a-z0-9._:-]+/g, "-").replace(/^-|-$/g, "").slice(0, 80) || fallback;
+}
+function stableSuffix(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+function taskEventField(data, keys) {
+  for (const key of keys) {
+    const direct = stringField(data[key]);
+    if (direct)
+      return direct;
+  }
+  const task = data.task;
+  if (task && typeof task === "object" && !Array.isArray(task)) {
+    for (const key of keys) {
+      const direct = stringField(task[key]);
+      if (direct)
+        return direct;
+    }
+  }
+  const payload = data.payload;
+  if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+    for (const key of keys) {
+      const direct = stringField(payload[key]);
+      if (direct)
+        return direct;
+    }
+  }
+  return;
+}
+async function readEventEnvelopeFromStdin() {
+  const raw = process.env.HASNA_EVENT_JSON || await Bun.stdin.text();
+  const event = JSON.parse(raw);
+  if (!event || typeof event !== "object" || Array.isArray(event))
+    throw new Error("event JSON must be an object");
+  if (!stringField(event.id))
+    throw new Error("event.id is required");
+  if (!stringField(event.type))
+    throw new Error("event.type is required");
+  if (!stringField(event.source))
+    throw new Error("event.source is required");
+  return event;
+}
 function providerAuthProfileFromOpts(opts, provider) {
   if (!opts.authProfile)
     return;
@@ -4542,6 +5016,40 @@ function providerAuthProfileFromOpts(opts, provider) {
     throw new Error("--auth-profile is currently supported only for --provider codewith");
   return opts.authProfile;
 }
+function sandboxFromOpts(opts, provider) {
+  if (!opts.sandbox)
+    return;
+  const codexLike = ["read-only", "workspace-write", "danger-full-access"];
+  const cursorLike = ["enabled", "disabled"];
+  if (["codewith", "codex"].includes(provider)) {
+    if (!codexLike.includes(opts.sandbox)) {
+      throw new Error("--sandbox must be read-only, workspace-write, or danger-full-access for codewith/codex");
+    }
+    return opts.sandbox;
+  }
+  if (provider === "cursor") {
+    if (!cursorLike.includes(opts.sandbox)) {
+      throw new Error("--sandbox must be enabled or disabled for cursor");
+    }
+    return opts.sandbox;
+  }
+  throw new Error("--sandbox is currently supported only for --provider codewith, codex, or cursor");
+}
+function permissionModeFromOpts(opts, provider) {
+  if (!opts.permissionMode)
+    return;
+  const mode = opts.permissionMode;
+  if (!["default", "plan", "auto", "bypass"].includes(mode)) {
+    throw new Error("--permission-mode must be default, plan, auto, or bypass");
+  }
+  if (mode === "plan" && !["claude", "cursor"].includes(provider)) {
+    throw new Error("--permission-mode plan is currently supported only for claude or cursor");
+  }
+  if (mode === "auto" && provider !== "claude") {
+    throw new Error("--permission-mode auto is currently supported only for claude");
+  }
+  return mode;
+}
 var create = program.command("create").description("create loops");
 addGoalOptions(addAccountOptions(addMachineOptions(addScheduleOptions(create.command("command <name>").description("create a deterministic shell command loop").requiredOption("--cmd <command>", "command string to execute").option("--cwd <dir>", "working directory").option("--timeout <duration>", "run timeout").option("--no-shell", "execute without a shell"))))).action((name, opts) => {
   const store = new Store;
@@ -4560,7 +5068,7 @@ addGoalOptions(addAccountOptions(addMachineOptions(addScheduleOptions(create.com
     store.close();
   }
 });
-addGoalOptions(addAccountOptions(addMachineOptions(addScheduleOptions(create.command("agent <name>").description("create a headless coding-agent loop").requiredOption("--provider <provider>", "claude, cursor, codewith, aicopilot, opencode, or codex").requiredOption("--prompt <prompt>", "agent prompt").option("--cwd <dir>", "working directory").option("--model <model>", "model").option("--agent <agent>", "provider-specific agent").option("--auth-profile <profile>", "provider-native auth profile; currently supported for codewith").option("--timeout <duration>", "run timeout").option("--config-isolation <mode>", "safe or none", "safe"))))).action((name, opts) => {
+addGoalOptions(addAccountOptions(addMachineOptions(addScheduleOptions(create.command("agent <name>").description("create a headless coding-agent loop").requiredOption("--provider <provider>", "claude, cursor, codewith, aicopilot, opencode, or codex").requiredOption("--prompt <prompt>", "agent prompt").option("--cwd <dir>", "working directory").option("--model <model>", "model").option("--variant <variant>", "provider-specific model variant or reasoning effort").option("--agent <agent>", "provider-specific agent").option("--auth-profile <profile>", "provider-native auth profile; currently supported for codewith").option("--timeout <duration>", "run timeout").option("--permission-mode <mode>", "provider permission mode: default, plan, auto, or bypass").option("--sandbox <mode>", "provider sandbox: codewith/codex use read-only/workspace-write/danger-full-access; cursor uses enabled/disabled").option("--config-isolation <mode>", "safe or none", "safe"))))).action((name, opts) => {
   const provider = opts.provider;
   if (!["claude", "cursor", "codewith", "aicopilot", "opencode", "codex"].includes(provider)) {
     throw new Error("unsupported provider");
@@ -4576,10 +5084,13 @@ addGoalOptions(addAccountOptions(addMachineOptions(addScheduleOptions(create.com
       prompt: opts.prompt,
       cwd: opts.cwd,
       model: opts.model,
+      variant: opts.variant,
       agent: opts.agent,
       authProfile: providerAuthProfileFromOpts(opts, provider),
       timeoutMs: opts.timeout ? parseDuration(opts.timeout) : undefined,
       configIsolation: opts.configIsolation,
+      permissionMode: permissionModeFromOpts(opts, provider),
+      sandbox: sandboxFromOpts(opts, provider),
       account: accountFromOpts(opts)
     };
     const loop = store.createLoop(baseCreateInput(name, opts, target));
@@ -4603,8 +5114,194 @@ addGoalOptions(addMachineOptions(addScheduleOptions(create.command("workflow <na
   }
 });
 var workflows = program.command("workflows").alias("workflow").description("manage workflow specs and runs");
+var templates = program.command("templates").alias("template").description("render and store reusable loop/workflow templates");
+var events = program.command("events").description("handle Hasna event envelopes from stdin or command transport");
 var machines = program.command("machines").description("inspect OpenMachines topology for loop assignment");
 var goal = program.command("goal").description("inspect goal runs");
+templates.command("list").alias("ls").description("list built-in OpenLoops templates").action(() => {
+  const values = listLoopTemplates();
+  if (isJson())
+    print(values);
+  else {
+    for (const template of values) {
+      console.log(`${template.id}	${template.kind}	${template.description}`);
+    }
+  }
+});
+templates.command("show <id>").description("show a built-in template").action((id) => {
+  const template = getLoopTemplate(id);
+  if (!template)
+    throw new Error(`template not found: ${id}`);
+  print(template, `${template.id} ${template.kind}`);
+});
+templates.command("render <id>").description("render a template as workflow JSON").option("--var <key=value>", "template variable; may be repeated", collectValues, []).action((id, opts) => {
+  const workflow = renderLoopTemplate(id, parseVars(opts.var));
+  print(workflow, JSON.stringify(workflow, null, 2));
+});
+templates.command("create-workflow <id>").description("render and store a template as a workflow").option("--var <key=value>", "template variable; may be repeated", collectValues, []).action((id, opts) => {
+  const store = new Store;
+  try {
+    const body = renderLoopTemplate(id, parseVars(opts.var));
+    const workflow = store.createWorkflow(body);
+    print(publicWorkflow(workflow), `created workflow ${workflow.id} (${workflow.name}) steps=${workflow.steps.length}`);
+  } finally {
+    store.close();
+  }
+});
+var eventsHandle = events.command("handle").description("handle a Hasna event envelope");
+eventsHandle.command("todos-task").description("create a one-shot worker/verifier workflow loop for a todos task event").option("--provider <provider>", "agent provider", "codewith").option("--auth-profile <profile>", "provider-native auth profile; currently supported for codewith").option("--account <profile>", "OpenAccounts profile name").option("--account-tool <tool>", "OpenAccounts tool id").option("--model <model>", "provider model").option("--variant <variant>", "provider-specific model variant or reasoning effort").option("--agent <agent>", "provider-specific agent").option("--permission-mode <mode>", "provider permission mode: default, plan, auto, or bypass", "bypass").option("--sandbox <mode>", "provider sandbox").option("--project-path <path>", "fallback project/repo working directory").option("--name-prefix <prefix>", "workflow/loop name prefix", "event:todos-task").option("--dry-run", "print the workflow and loop input without storing anything").action(async (opts) => {
+  const event = await readEventEnvelopeFromStdin();
+  const data = eventData(event);
+  const metadata = eventMetadata(event);
+  const taskId = taskEventField(data, ["id", "task_id", "taskId"]);
+  if (!taskId)
+    throw new Error("todos task event is missing task id in data.id, data.task_id, data.task.id, or data.payload.id");
+  const taskTitle = taskEventField(data, ["title", "task_title", "taskTitle"]);
+  const taskDescription = taskEventField(data, ["description", "body"]);
+  const dataProjectPath = taskEventField(data, ["working_dir", "workingDir", "project_path", "projectPath", "cwd"]);
+  const metadataProjectPath = taskEventField(metadata, [
+    "working_dir",
+    "workingDir",
+    "project_path",
+    "projectPath",
+    "project_canonical_path",
+    "cwd"
+  ]);
+  const projectPath = opts.projectPath ?? dataProjectPath ?? metadataProjectPath ?? process.cwd();
+  const idempotencyKey = `todos-task:${taskId}:${event.type}`;
+  const provider = opts.provider;
+  if (!["claude", "cursor", "codewith", "aicopilot", "opencode", "codex"].includes(provider))
+    throw new Error("unsupported provider");
+  const permissionMode = permissionModeFromOpts({ permissionMode: opts.permissionMode }, provider);
+  const sandbox = sandboxFromOpts({ sandbox: opts.sandbox }, provider);
+  const authProfile = providerAuthProfileFromOpts({ authProfile: opts.authProfile }, provider);
+  const workflowBody = renderTodosTaskWorkerVerifierWorkflow({
+    taskId,
+    taskTitle,
+    taskDescription,
+    projectPath,
+    provider,
+    authProfile,
+    account: accountFromOpts(opts),
+    model: opts.model,
+    variant: opts.variant,
+    agent: opts.agent,
+    permissionMode,
+    sandbox,
+    eventId: event.id,
+    eventType: event.type
+  });
+  const idempotencySuffix = stableSuffix(idempotencyKey);
+  workflowBody.name = `${opts.namePrefix}:${taskId.slice(0, 8)}:${idempotencySuffix}:workflow`;
+  workflowBody.description = `Task-triggered worker/verifier workflow for ${taskTitle ?? taskId} from ${event.source}/${event.type}; ` + `idempotency=${idempotencyKey}; event=${event.id}`;
+  const loopName = `${opts.namePrefix}:${taskId.slice(0, 8)}:${idempotencySuffix}:run`;
+  const legacyLoopName = `${opts.namePrefix}:${taskId.slice(0, 8)}:${event.id.slice(0, 8)}:run`;
+  const loopInput = {
+    name: loopName,
+    description: `Run ${workflowBody.name} once for task ${taskId}; idempotency=${idempotencyKey}; event=${event.id}`,
+    schedule: { type: "once", at: new Date(Date.now() + 1000).toISOString() },
+    target: { type: "workflow", workflowId: "<created-workflow-id>" },
+    overlap: "skip",
+    maxAttempts: 1,
+    retryDelayMs: 60000,
+    leaseMs: 90 * 60000
+  };
+  if (opts.dryRun) {
+    print({ deduped: false, idempotencyKey, event, workflow: workflowBody, loop: loopInput }, `dry-run ${loopName}`);
+    return;
+  }
+  const store = new Store;
+  try {
+    const existingLoop = store.findLoopByName(loopName) ?? store.findLoopByName(legacyLoopName);
+    if (existingLoop) {
+      const existingWorkflow2 = existingLoop.target.type === "workflow" ? store.getWorkflow(existingLoop.target.workflowId) : undefined;
+      print({
+        deduped: true,
+        idempotencyKey,
+        dedupedBy: existingLoop.name === loopName ? "idempotency" : "legacy-event-name",
+        event,
+        workflow: existingWorkflow2 ? publicWorkflow(existingWorkflow2) : undefined,
+        loop: publicLoop(existingLoop)
+      }, `deduped existing loop ${existingLoop.id} (${existingLoop.name}) for event=${event.id} idempotency=${idempotencyKey}`);
+      return;
+    }
+    const existingWorkflow = store.findWorkflowByName(workflowBody.name);
+    const workflow = existingWorkflow ?? store.createWorkflow(workflowBody);
+    const loop = store.createLoop({
+      ...loopInput,
+      target: { type: "workflow", workflowId: workflow.id }
+    });
+    print({ deduped: false, idempotencyKey, event, workflow: publicWorkflow(workflow), loop: publicLoop(loop) }, `created ${loop.id} (${loop.name}) workflow=${workflow.name} event=${event.id} idempotency=${idempotencyKey}`);
+  } finally {
+    store.close();
+  }
+});
+eventsHandle.command("generic").description("create a one-shot worker/verifier workflow loop for any Hasna event").option("--provider <provider>", "agent provider", "codewith").option("--auth-profile <profile>", "provider-native auth profile; currently supported for codewith").option("--account <profile>", "OpenAccounts profile name").option("--account-tool <tool>", "OpenAccounts tool id").option("--model <model>", "provider model").option("--variant <variant>", "provider-specific model variant or reasoning effort").option("--agent <agent>", "provider-specific agent").option("--permission-mode <mode>", "provider permission mode: default, plan, auto, or bypass", "bypass").option("--sandbox <mode>", "provider sandbox").option("--project-path <path>", "fallback project/repo working directory").option("--name-prefix <prefix>", "workflow/loop name prefix", "event:generic").option("--dry-run", "print the workflow and loop input without storing anything").action(async (opts) => {
+  const event = await readEventEnvelopeFromStdin();
+  const data = eventData(event);
+  const projectPath = opts.projectPath ?? taskEventField(data, ["working_dir", "workingDir", "project_path", "projectPath", "cwd", "repo_path", "repoPath"]) ?? process.cwd();
+  const provider = opts.provider;
+  if (!["claude", "cursor", "codewith", "aicopilot", "opencode", "codex"].includes(provider))
+    throw new Error("unsupported provider");
+  const permissionMode = permissionModeFromOpts({ permissionMode: opts.permissionMode }, provider);
+  const sandbox = sandboxFromOpts({ sandbox: opts.sandbox }, provider);
+  const authProfile = providerAuthProfileFromOpts({ authProfile: opts.authProfile }, provider);
+  const workflowBody = renderEventWorkerVerifierWorkflow({
+    eventId: event.id,
+    eventType: event.type,
+    eventSource: event.source,
+    eventSubject: stringField(event.subject),
+    eventMessage: stringField(event.message),
+    eventJson: JSON.stringify(event),
+    projectPath,
+    provider,
+    authProfile,
+    account: accountFromOpts(opts),
+    model: opts.model,
+    variant: opts.variant,
+    agent: opts.agent,
+    permissionMode,
+    sandbox
+  });
+  const eventSuffix = event.id.slice(0, 8);
+  const source = slugSegment(event.source, "source");
+  const type = slugSegment(event.type, "type");
+  workflowBody.name = `${opts.namePrefix}:${source}:${type}:${eventSuffix}:workflow`;
+  workflowBody.description = `Event-triggered worker/verifier workflow for ${event.source}/${event.type}`;
+  const loopName = `${opts.namePrefix}:${source}:${type}:${eventSuffix}:run`;
+  const loopInput = {
+    name: loopName,
+    description: `Run ${workflowBody.name} once for event ${event.id}`,
+    schedule: { type: "once", at: new Date(Date.now() + 1000).toISOString() },
+    target: { type: "workflow", workflowId: "<created-workflow-id>" },
+    overlap: "skip",
+    maxAttempts: 1,
+    retryDelayMs: 60000,
+    leaseMs: 90 * 60000
+  };
+  if (opts.dryRun) {
+    print({ event, workflow: workflowBody, loop: loopInput }, `dry-run ${loopName}`);
+    return;
+  }
+  const store = new Store;
+  try {
+    const existingLoop = store.findLoopByName(loopName);
+    if (existingLoop) {
+      const existingWorkflow2 = existingLoop.target.type === "workflow" ? store.getWorkflow(existingLoop.target.workflowId) : undefined;
+      print({ deduped: true, event, workflow: existingWorkflow2 ? publicWorkflow(existingWorkflow2) : undefined, loop: publicLoop(existingLoop) }, `deduped existing loop ${existingLoop.id} (${existingLoop.name})`);
+      return;
+    }
+    const existingWorkflow = store.findWorkflowByName(workflowBody.name);
+    const workflow = existingWorkflow ?? store.createWorkflow(workflowBody);
+    const loop = store.createLoop({
+      ...loopInput,
+      target: { type: "workflow", workflowId: workflow.id }
+    });
+    print({ deduped: false, event, workflow: publicWorkflow(workflow), loop: publicLoop(loop) }, `created ${loop.id} (${loop.name}) workflow=${workflow.name}`);
+  } finally {
+    store.close();
+  }
+});
 goal.command("show <idOrName>").description("show a goal or configured loop/workflow goal").action((idOrName) => {
   const store = new Store;
   try {
@@ -4718,11 +5415,11 @@ workflows.command("inspect <runId>").description("show a workflow run with steps
   try {
     const run = store.requireWorkflowRun(runId);
     const steps = store.listWorkflowStepRuns(run.id);
-    const events = store.listWorkflowEvents(run.id);
+    const events2 = store.listWorkflowEvents(run.id);
     const value = {
       workflowRun: publicWorkflowRun(run),
       steps: steps.map((step) => publicWorkflowStepRun(step)),
-      events: events.map(publicWorkflowEvent)
+      events: events2.map(publicWorkflowEvent)
     };
     if (isJson())
       print(value);
@@ -4732,7 +5429,7 @@ workflows.command("inspect <runId>").description("show a workflow run with steps
         const publicStep = publicWorkflowStepRun(step);
         console.log(`  ${String(step.sequence).padStart(2, "0")}  ${step.status.padEnd(10)}  ${step.stepId}  ${publicStep.error ?? ""}`);
       }
-      console.log(`  events=${events.length}`);
+      console.log(`  events=${events2.length}`);
     }
   } finally {
     store.close();
@@ -4784,11 +5481,11 @@ workflows.command("runs [idOrName]").option("--limit <n>", "limit", "50").action
 workflows.command("events <runId>").option("--limit <n>", "limit", "200").action((runId, opts) => {
   const store = new Store;
   try {
-    const events = store.listWorkflowEvents(runId, Number(opts.limit));
+    const events2 = store.listWorkflowEvents(runId, Number(opts.limit));
     if (isJson())
-      print(events.map(publicWorkflowEvent));
+      print(events2.map(publicWorkflowEvent));
     else {
-      for (const event of events) {
+      for (const event of events2) {
         console.log(`${String(event.sequence).padStart(3, "0")}  ${event.eventType.padEnd(14)}  ${event.stepId ?? "-"}  ${event.createdAt}`);
       }
     }