@agentic-ops/engine-sdk 0.1.0

package/dist/workflow.cjs

@@ -0,0 +1,663 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/workflow.ts
+var workflow_exports = {};
+__export(workflow_exports, {
+  ENGINE_QUEUE: () => ENGINE_QUEUE,
+  childDevCycle: () => childDevCycle,
+  engineActivities: () => engineActivities,
+  engineAgent: () => engineAgent,
+  interceptors: () => interceptors,
+  parseFindings: () => parseFindings,
+  parseVerdict: () => parseVerdict
+});
+module.exports = __toCommonJS(workflow_exports);
+var import_workflow = require("@temporalio/workflow");
+var import_common = require("@temporalio/common");
+
+// ../contracts/src/stage.ts
+var import_zod = require("zod");
+var StageSchema = import_zod.z.enum([
+  "context",
+  "assess",
+  "design",
+  "plan",
+  "implement",
+  "full_verify",
+  "review",
+  "pr",
+  "pr_babysit",
+  "done",
+  "failed",
+  "platform",
+  "bughunt",
+  "agent"
+]);
+var TaskStatusSchema = import_zod.z.enum(["pending", "running", "blocked", "done", "failed"]);
+var BlockReasonSchema = import_zod.z.enum([
+  "needs-clarification",
+  "iteration-brake",
+  "token-brake",
+  "babysit-brake",
+  "max-attempts",
+  "hook-required-failed",
+  // A LiteLLM virtual key's hard spend cap, not a token-count brake -- kept
+  // distinct from 'token-brake' since the two are independent enforcement
+  // layers (ARCHITECTURE.md §7) that can trip for unrelated reasons.
+  "budget-exceeded",
+  // A prompt-started devCycle (no pre-resolved config) whose repo isn't in
+  // the worker's merged static+managed registry -- set together with
+  // status 'failed' as a fail-fast, not a resumable block (prompt-devcycle
+  // design §5/§7).
+  "unregistered-repo"
+]);
+
+// ../contracts/src/model.ts
+var import_zod2 = require("zod");
+var ModelRefSchema = import_zod2.z.object({
+  // 'litellm' is a transport kind (an HTTP call through the LiteLLM gateway),
+  // not a provider -- `model` is the LiteLLM-side model_list alias (e.g.
+  // "zai-glm-4.6"), never a raw provider string. See agentops-platform's
+  // litellm-deploy-design.md for why that indirection matters.
+  backend: import_zod2.z.enum(["claude", "cursor", "pi", "codex", "stub", "litellm"]),
+  model: import_zod2.z.string().min(1),
+  effort: import_zod2.z.enum(["low", "medium", "high", "xhigh", "max"]).optional()
+});
+var BrakesSchema = import_zod2.z.object({
+  maxImplementAttempts: import_zod2.z.number().int().positive().default(3),
+  maxIterations: import_zod2.z.number().int().positive(),
+  maxTokens: import_zod2.z.number().int().positive(),
+  maxBabysitRounds: import_zod2.z.number().int().positive()
+});
+var RoutingSchema = import_zod2.z.object({
+  context: ModelRefSchema.optional(),
+  assess: ModelRefSchema.optional(),
+  design: ModelRefSchema.optional(),
+  plan: ModelRefSchema.optional(),
+  implement: ModelRefSchema.optional(),
+  full_verify: ModelRefSchema.optional(),
+  review: ModelRefSchema.optional(),
+  pr: ModelRefSchema.optional(),
+  pr_babysit: ModelRefSchema.optional(),
+  bughunt: ModelRefSchema.optional(),
+  agent: ModelRefSchema.optional()
+});
+var StageTimeoutSchema = import_zod2.z.object({
+  idleTimeoutMs: import_zod2.z.number().int().positive().optional(),
+  timeoutMs: import_zod2.z.number().int().positive().optional()
+});
+var TimeoutsSchema = import_zod2.z.object({
+  context: StageTimeoutSchema.optional(),
+  assess: StageTimeoutSchema.optional(),
+  design: StageTimeoutSchema.optional(),
+  plan: StageTimeoutSchema.optional(),
+  implement: StageTimeoutSchema.optional(),
+  full_verify: StageTimeoutSchema.optional(),
+  review: StageTimeoutSchema.optional(),
+  pr: StageTimeoutSchema.optional(),
+  pr_babysit: StageTimeoutSchema.optional(),
+  bughunt: StageTimeoutSchema.optional(),
+  agent: StageTimeoutSchema.optional()
+});
+var StageToggleSchema = import_zod2.z.object({
+  assess: import_zod2.z.boolean().optional(),
+  triage: import_zod2.z.boolean().optional()
+});
+
+// ../contracts/src/project-config.ts
+var import_zod3 = require("zod");
+var VerifyServiceReadinessSchema = import_zod3.z.discriminatedUnion("type", [
+  import_zod3.z.object({ type: import_zod3.z.literal("exec"), command: import_zod3.z.array(import_zod3.z.string()).min(1) }),
+  import_zod3.z.object({ type: import_zod3.z.literal("tcpSocket"), port: import_zod3.z.number().int().positive() })
+]);
+var VerifyServiceSchema = import_zod3.z.object({
+  name: import_zod3.z.string().min(1),
+  image: import_zod3.z.string().min(1),
+  env: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).optional(),
+  readiness: VerifyServiceReadinessSchema
+});
+var ProjectConfigSchema = import_zod3.z.object({
+  image: import_zod3.z.string().min(1).optional(),
+  services: import_zod3.z.array(VerifyServiceSchema).optional(),
+  initCommands: import_zod3.z.array(import_zod3.z.string()).optional(),
+  fastVerifyCommands: import_zod3.z.array(import_zod3.z.string()).optional(),
+  fullVerifyCommands: import_zod3.z.array(import_zod3.z.string()).optional(),
+  stages: StageToggleSchema,
+  routing: RoutingSchema,
+  escalation: ModelRefSchema.optional(),
+  brakes: BrakesSchema,
+  timeouts: TimeoutsSchema.optional()
+});
+
+// ../contracts/src/task-input.ts
+var import_zod4 = require("zod");
+var TaskInputSchema = import_zod4.z.object({
+  taskId: import_zod4.z.string().min(1),
+  project: import_zod4.z.string().min(1),
+  repo: import_zod4.z.string().min(1),
+  issueRef: import_zod4.z.string().optional(),
+  goal: import_zod4.z.string().min(1),
+  // Optional since the prompt-devcycle design (2026-07-09): when absent, the
+  // devCycle workflow resolves it on the worker via resolveRepoConfig.
+  // Gateway/CLI/platform-children keep pre-resolving and passing it.
+  config: ProjectConfigSchema.optional()
+});
+
+// ../contracts/src/dev-cycle-state.ts
+var import_zod5 = require("zod");
+var DevCycleStateSchema = import_zod5.z.object({
+  taskId: import_zod5.z.string().min(1),
+  stage: StageSchema,
+  status: TaskStatusSchema,
+  blockReason: BlockReasonSchema.nullable(),
+  implementAttempts: import_zod5.z.number().int().nonnegative(),
+  iterations: import_zod5.z.number().int().nonnegative(),
+  cumulativeTokens: import_zod5.z.number().int().nonnegative(),
+  babysitRounds: import_zod5.z.number().int().nonnegative(),
+  prRef: import_zod5.z.string().nullable(),
+  workspaceRef: import_zod5.z.string(),
+  branch: import_zod5.z.string()
+});
+
+// ../contracts/src/stage-result.ts
+var import_zod6 = require("zod");
+var StageSourceSchema = import_zod6.z.enum(["agent", "human", "triage"]);
+var StageOutcomeSchema = import_zod6.z.enum(["pass", "fail", "unparseable", "skipped"]);
+var StageResultSchema = import_zod6.z.object({
+  stage: StageSchema,
+  source: StageSourceSchema,
+  contentHash: import_zod6.z.string().min(1),
+  tokens: import_zod6.z.number().int().nonnegative(),
+  outcome: StageOutcomeSchema
+});
+
+// ../contracts/src/verdict.ts
+var import_zod7 = require("zod");
+var VerdictKindSchema = import_zod7.z.enum(["pass", "fail", "unparseable"]);
+var VerdictSchema = import_zod7.z.object({
+  kind: VerdictKindSchema,
+  findings: import_zod7.z.array(import_zod7.z.string()).optional()
+});
+
+// ../contracts/src/agent-run.ts
+var import_zod8 = require("zod");
+var AgentRunLimitsSchema = import_zod8.z.object({
+  maxTokens: import_zod8.z.number().int().positive(),
+  idleTimeoutMs: import_zod8.z.number().int().positive().optional(),
+  timeoutMs: import_zod8.z.number().int().positive()
+});
+var EffortSchema = import_zod8.z.enum(["low", "medium", "high", "xhigh", "max"]);
+var AgentRunRequestSchema = import_zod8.z.object({
+  taskId: import_zod8.z.string().min(1),
+  stage: StageSchema,
+  attempt: import_zod8.z.number().int().positive(),
+  callIndex: import_zod8.z.number().int().positive().default(1),
+  backend: import_zod8.z.string().min(1),
+  model: import_zod8.z.string().min(1),
+  effort: EffortSchema.optional(),
+  image: import_zod8.z.string().min(1).optional(),
+  services: import_zod8.z.array(VerifyServiceSchema).optional(),
+  promptRef: import_zod8.z.string().min(1),
+  promptContext: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()).default({}),
+  promptSource: import_zod8.z.object({ repo: import_zod8.z.string().min(1), commit: import_zod8.z.string().min(1), path: import_zod8.z.string().min(1) }).optional(),
+  workspaceRef: import_zod8.z.string().min(1),
+  limits: AgentRunLimitsSchema
+});
+var BackendRunRequestSchema = AgentRunRequestSchema.omit({ promptRef: true, promptContext: true }).extend({
+  prompt: import_zod8.z.string().min(1)
+});
+var AgentRunResultSchema = import_zod8.z.object({
+  output: import_zod8.z.string(),
+  tokensIn: import_zod8.z.number().int().nonnegative(),
+  tokensOut: import_zod8.z.number().int().nonnegative(),
+  wallMs: import_zod8.z.number().int().nonnegative()
+});
+
+// ../contracts/src/run-stats.ts
+var import_zod9 = require("zod");
+var RunStatsSchema = import_zod9.z.object({
+  taskId: import_zod9.z.string().min(1),
+  stage: StageSchema,
+  backend: import_zod9.z.string().min(1),
+  model: import_zod9.z.string().min(1),
+  tokensIn: import_zod9.z.number().int().nonnegative(),
+  tokensOut: import_zod9.z.number().int().nonnegative(),
+  wallMs: import_zod9.z.number().int().nonnegative(),
+  outcome: StageOutcomeSchema,
+  // provenance + attribution (design §7) — optional so existing call sites compile
+  promptHash: import_zod9.z.string().optional(),
+  promptSource: import_zod9.z.string().optional(),
+  project: import_zod9.z.string().optional(),
+  workflowType: import_zod9.z.string().optional()
+});
+
+// ../contracts/src/pr-feedback.ts
+var import_zod10 = require("zod");
+
+// ../contracts/src/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+
+// ../contracts/src/pr-feedback.ts
+var CiStatusSchema = import_zod10.z.enum(["pending", "green", "failed"]);
+var PrCommentSchema = import_zod10.z.object({
+  id: import_zod10.z.string().min(1),
+  body: import_zod10.z.string(),
+  resolved: import_zod10.z.boolean()
+});
+var PrFeedbackSchema = import_zod10.z.object({
+  ciStatus: CiStatusSchema,
+  unresolvedThreads: import_zod10.z.number().int().nonnegative(),
+  comments: import_zod10.z.array(PrCommentSchema)
+});
+
+// ../contracts/src/managed-project.ts
+var import_zod11 = require("zod");
+var BaseManagedProjectFields = {
+  id: import_zod11.z.string().uuid(),
+  project: import_zod11.z.string().min(1),
+  repo: import_zod11.z.string().min(1),
+  credentialSet: import_zod11.z.boolean(),
+  // GitHub token set? never the token itself
+  config: ProjectConfigSchema.nullable(),
+  createdAt: import_zod11.z.string(),
+  updatedAt: import_zod11.z.string()
+};
+var ManagedProjectSchema = import_zod11.z.discriminatedUnion("trackerType", [
+  import_zod11.z.object({ ...BaseManagedProjectFields, trackerType: import_zod11.z.literal("github") }),
+  import_zod11.z.object({
+    ...BaseManagedProjectFields,
+    trackerType: import_zod11.z.literal("linear"),
+    linearTeamKey: import_zod11.z.string().min(1),
+    linearTriggerLabelId: import_zod11.z.string().min(1),
+    linearCredentialSet: import_zod11.z.boolean()
+    // Linear token set? never the token itself
+  })
+]);
+var UpsertManagedProjectRequestSchema = import_zod11.z.object({
+  project: import_zod11.z.string().min(1),
+  repo: import_zod11.z.string().min(1),
+  token: import_zod11.z.string().min(1).optional(),
+  config: ProjectConfigSchema.nullable().optional(),
+  trackerType: import_zod11.z.enum(["github", "linear"]).default("github"),
+  linearTeamKey: import_zod11.z.string().min(1).optional(),
+  linearTriggerLabelId: import_zod11.z.string().min(1).optional(),
+  linearToken: import_zod11.z.string().min(1).optional()
+});
+
+// ../contracts/src/platform-agent.ts
+var import_zod12 = require("zod");
+var ProposedFixSchema = import_zod12.z.object({
+  repo: import_zod12.z.string().min(1),
+  goal: import_zod12.z.string().min(1)
+});
+var SkippedFixSchema = ProposedFixSchema.extend({
+  reason: import_zod12.z.string().min(1)
+});
+var PlatformActionSchema = import_zod12.z.object({
+  type: import_zod12.z.enum(["terminate", "signal"]),
+  workflowId: import_zod12.z.string().min(1),
+  reason: import_zod12.z.string().min(1)
+});
+var PlatformSentinelSchema = import_zod12.z.object({
+  summary: import_zod12.z.string().min(1),
+  actionsTaken: import_zod12.z.array(PlatformActionSchema).default([]),
+  proposedFixes: import_zod12.z.array(ProposedFixSchema).default([])
+});
+var PlatformAgentInputSchema = import_zod12.z.object({
+  prompt: import_zod12.z.string().min(1),
+  hintRepos: import_zod12.z.array(import_zod12.z.string()).optional()
+});
+var PlatformAgentResultSchema = import_zod12.z.object({
+  summary: import_zod12.z.string(),
+  actionsTaken: import_zod12.z.array(PlatformActionSchema).default([]),
+  childWorkflows: import_zod12.z.array(
+    import_zod12.z.object({
+      workflowId: import_zod12.z.string().min(1),
+      repo: import_zod12.z.string().min(1),
+      goal: import_zod12.z.string().min(1)
+    })
+  ).default([]),
+  skippedFixes: import_zod12.z.array(SkippedFixSchema).default([])
+});
+
+// ../contracts/src/control-api.ts
+var import_zod13 = require("zod");
+var StartRunRequestSchema = import_zod13.z.object({
+  prompt: import_zod13.z.string().min(1),
+  hintRepos: import_zod13.z.array(import_zod13.z.string()).optional(),
+  workflowId: import_zod13.z.string().min(1).optional()
+});
+var StartRunResponseSchema = import_zod13.z.object({
+  workflowId: import_zod13.z.string().min(1),
+  runId: import_zod13.z.string().min(1)
+});
+var RunStatusSchema = import_zod13.z.enum([
+  "RUNNING",
+  "COMPLETED",
+  "FAILED",
+  "CANCELLED",
+  "TERMINATED",
+  "TIMED_OUT",
+  "CONTINUED_AS_NEW"
+]);
+var RunListItemSchema = import_zod13.z.object({
+  workflowId: import_zod13.z.string().min(1),
+  runId: import_zod13.z.string().min(1),
+  status: RunStatusSchema,
+  startTime: import_zod13.z.string().min(1),
+  closeTime: import_zod13.z.string().min(1).optional(),
+  // Truncated prompt text from the Temporal memo set at start -- NOT
+  // PlatformAgentResult.summary, which only exists once a run completes.
+  promptSnippet: import_zod13.z.string().min(1).optional()
+});
+var RunDetailSchema = import_zod13.z.object({
+  workflowId: import_zod13.z.string().min(1),
+  runId: import_zod13.z.string().min(1),
+  status: RunStatusSchema,
+  prompt: import_zod13.z.string().min(1).optional(),
+  result: PlatformAgentResultSchema.optional(),
+  error: import_zod13.z.string().min(1).optional(),
+  temporalUrl: import_zod13.z.string().min(1)
+});
+var RepoListResponseSchema = import_zod13.z.object({
+  repos: import_zod13.z.array(import_zod13.z.string())
+});
+
+// ../contracts/src/control-devcycle-api.ts
+var import_zod14 = require("zod");
+var StartDevCycleRequestSchema = import_zod14.z.object({
+  repo: import_zod14.z.string().min(1),
+  // owner/repo -- must resolve to a registered project (422 otherwise)
+  prompt: import_zod14.z.string().min(1),
+  // becomes TaskInput.goal verbatim
+  taskId: import_zod14.z.string().min(1).optional()
+  // default: randomUUID() in control
+});
+var StartDevCycleResponseSchema = import_zod14.z.object({
+  workflowId: import_zod14.z.string().min(1),
+  runId: import_zod14.z.string().min(1),
+  taskId: import_zod14.z.string().min(1)
+});
+var DevCycleRunDetailSchema = import_zod14.z.object({
+  workflowId: import_zod14.z.string().min(1),
+  runId: import_zod14.z.string().min(1),
+  status: RunStatusSchema,
+  prompt: import_zod14.z.string().min(1).optional(),
+  // from the Temporal memo; absent for gateway/CLI-started runs
+  state: DevCycleStateSchema.optional(),
+  // live 'state' query while RUNNING, workflow result once COMPLETED
+  error: import_zod14.z.string().min(1).optional(),
+  temporalUrl: import_zod14.z.string().min(1)
+});
+var DevCycleTargetSchema = import_zod14.z.object({
+  repo: import_zod14.z.string().min(1),
+  project: import_zod14.z.string().min(1)
+});
+var DevCycleTargetsResponseSchema = import_zod14.z.object({
+  targets: import_zod14.z.array(DevCycleTargetSchema)
+});
+
+// ../contracts/src/control-projects-api.ts
+var import_zod15 = require("zod");
+var CreateManagedProjectRequestSchema = import_zod15.z.object({
+  project: import_zod15.z.string().min(1),
+  repo: import_zod15.z.string().min(1),
+  token: import_zod15.z.string().min(1),
+  config: ProjectConfigSchema.nullable().optional(),
+  trackerType: import_zod15.z.enum(["github", "linear"]).default("github"),
+  linearTeamKey: import_zod15.z.string().min(1).optional(),
+  linearTriggerLabelId: import_zod15.z.string().min(1).optional(),
+  linearToken: import_zod15.z.string().min(1).optional()
+}).superRefine((data, ctx) => {
+  if (data.trackerType !== "linear") {
+    return;
+  }
+  if (!data.linearTeamKey) {
+    ctx.addIssue({ code: "custom", path: ["linearTeamKey"], message: 'linearTeamKey is required when trackerType is "linear"' });
+  }
+  if (!data.linearTriggerLabelId) {
+    ctx.addIssue({ code: "custom", path: ["linearTriggerLabelId"], message: 'linearTriggerLabelId is required when trackerType is "linear"' });
+  }
+  if (!data.linearToken) {
+    ctx.addIssue({ code: "custom", path: ["linearToken"], message: 'linearToken is required when trackerType is "linear"' });
+  }
+});
+var UpdateManagedProjectRequestSchema = import_zod15.z.object({
+  token: import_zod15.z.string().min(1).optional(),
+  config: ProjectConfigSchema.nullable().optional(),
+  linearTeamKey: import_zod15.z.string().min(1).optional(),
+  linearTriggerLabelId: import_zod15.z.string().min(1).optional(),
+  linearToken: import_zod15.z.string().min(1).optional()
+});
+var ManagedProjectListResponseSchema = import_zod15.z.array(ManagedProjectSchema);
+
+// ../contracts/src/control-agents-api.ts
+var import_zod16 = require("zod");
+var AgentScheduleSummarySchema = import_zod16.z.object({
+  scheduleId: import_zod16.z.string().min(1),
+  project: import_zod16.z.string().min(1),
+  agentName: import_zod16.z.string().min(1),
+  workflow: import_zod16.z.string().min(1),
+  cron: import_zod16.z.string().min(1),
+  paused: import_zod16.z.boolean(),
+  nextRun: import_zod16.z.string().optional()
+});
+var ListAgentSchedulesResponseSchema = import_zod16.z.object({
+  agents: import_zod16.z.array(AgentScheduleSummarySchema)
+});
+var TriggerAgentResponseSchema = import_zod16.z.object({
+  scheduleId: import_zod16.z.string().min(1),
+  triggered: import_zod16.z.boolean()
+});
+
+// ../contracts/src/agents-manifest.ts
+var import_zod17 = require("zod");
+var CRON_FIELD = String.raw`[\d*/,\-A-Za-z?]+`;
+var CRON_RE = new RegExp(`^${CRON_FIELD}(\\s+${CRON_FIELD}){4}$`);
+var scheduleSchema = import_zod17.z.union([import_zod17.z.literal("continuous"), import_zod17.z.string().regex(CRON_RE, 'must be a 5-field cron or "continuous"')]);
+var AgentSpecSchema = import_zod17.z.object({
+  name: import_zod17.z.string().regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, "name must be kebab-case DNS-safe"),
+  workflow: import_zod17.z.string().min(1),
+  schedule: scheduleSchema,
+  input: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.unknown()).default({}),
+  enabled: import_zod17.z.boolean().default(true),
+  timezone: import_zod17.z.string().default("UTC"),
+  overlap: import_zod17.z.enum(["skip", "bufferOne", "allow"]).default("skip"),
+  // Task queue the reconciler starts this agent on. Built-in workflows omit
+  // it (they run on ENGINE_QUEUE); a continuous Tier-2 agent sets it to its
+  // project worker's queue so the reconciler can start it by name there.
+  taskQueue: import_zod17.z.string().min(1).optional()
+}).strict();
+var AgentsManifestSchema = import_zod17.z.object({ agents: import_zod17.z.array(AgentSpecSchema) }).strict();
+var WhiteboxBugHuntManifestInputSchema = import_zod17.z.object({ focus: import_zod17.z.string().optional() }).strict();
+
+// ../contracts/src/whitebox-finding.ts
+var import_zod18 = require("zod");
+var WhiteboxFindingSchema = import_zod18.z.object({
+  title: import_zod18.z.string().min(1),
+  detail: import_zod18.z.string().min(1),
+  severity: import_zod18.z.enum(["low", "medium", "high", "critical"]),
+  location: import_zod18.z.string().min(1)
+  // e.g. "src/db.ts:42"
+});
+
+// ../contracts/src/engine-queue.ts
+var ENGINE_QUEUE = "agentops-engine";
+
+// ../contracts/src/project-identity.ts
+var PROJECT_HEADER_KEY = "x-agentops-project";
+function readProjectFromMemo(memo) {
+  const p = memo?.project;
+  return typeof p === "string" && p.length > 0 ? p : void 0;
+}
+
+// ../contracts/src/index.ts
+var import_zod19 = require("zod");
+
+// ../policies/src/parse-verdict.ts
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var SENTINEL_PREFIX = "[\\s>#*_-]{0,6}";
+function parseVerdict(text, sentinel) {
+  const pattern = new RegExp(`^${SENTINEL_PREFIX}${escapeRegExp(sentinel)}\\s*(PASS|FAIL)\\b(.*)$`, "gm");
+  let lastMatch = null;
+  let match;
+  while ((match = pattern.exec(text)) !== null) {
+    lastMatch = match;
+  }
+  if (!lastMatch) {
+    return { kind: "unparseable" };
+  }
+  const [, verdictWord, rest] = lastMatch;
+  const kind = verdictWord === "PASS" ? "pass" : "fail";
+  const findingsText = rest.trim().replace(/[\s*_]+$/, "");
+  return findingsText.length > 0 ? { kind, findings: [findingsText] } : { kind };
+}
+
+// ../policies/src/parse-findings.ts
+function parseFindings(output) {
+  const re = /^FINDINGS:\s*(.+)$/gm;
+  let last = null;
+  for (let m = re.exec(output); m !== null; m = re.exec(output)) last = m;
+  if (!last) return [];
+  let json;
+  try {
+    json = JSON.parse(last[1]);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(json)) return [];
+  const out = [];
+  for (const item of json) {
+    const res = WhiteboxFindingSchema.safeParse(item);
+    if (res.success) out.push(res.data);
+  }
+  return out;
+}
+
+// src/workflow.ts
+function engineActivities(opts = {}) {
+  return (0, import_workflow.proxyActivities)({ taskQueue: ENGINE_QUEUE, startToCloseTimeout: opts.startToCloseTimeout ?? "10m" });
+}
+function engineAgent(opts = {}) {
+  return (0, import_workflow.proxyActivities)({ taskQueue: ENGINE_QUEUE, startToCloseTimeout: opts.startToCloseTimeout ?? "1h" });
+}
+function childDevCycle(input) {
+  return (0, import_workflow.executeChild)("devCycle", { taskQueue: ENGINE_QUEUE, args: [input] });
+}
+var ProjectOutbound = class {
+  project() {
+    return readProjectFromMemo((0, import_workflow.workflowInfo)().memo);
+  }
+  async scheduleActivity(input, next) {
+    const p = this.project();
+    if (p) input.headers = { ...input.headers, [PROJECT_HEADER_KEY]: import_common.defaultPayloadConverter.toPayload(p) };
+    return next(input);
+  }
+  async startChildWorkflowExecution(input, next) {
+    const p = this.project();
+    if (p) {
+      input.headers = { ...input.headers, [PROJECT_HEADER_KEY]: import_common.defaultPayloadConverter.toPayload(p) };
+      input.options = {
+        ...input.options,
+        memo: { ...input.options?.memo ?? {}, project: p },
+        searchAttributes: { ...input.options?.searchAttributes ?? {}, project: [p] }
+      };
+    }
+    return next(input);
+  }
+};
+var interceptors = () => ({ outbound: [new ProjectOutbound()] });
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ENGINE_QUEUE,
+  childDevCycle,
+  engineActivities,
+  engineAgent,
+  interceptors,
+  parseFindings,
+  parseVerdict
+});

package/dist/workflow.d.cts

@@ -0,0 +1,16 @@
+import * as _temporalio_workflow from '@temporalio/workflow';
+import { WorkflowInterceptorsFactory } from '@temporalio/workflow';
+import { TaskInput, DevCycleState, EngineActivities } from '@agentops/contracts';
+export { ENGINE_QUEUE, EngineActivities } from '@agentops/contracts';
+export { parseFindings, parseVerdict } from '@agentops/policies';
+
+declare function engineActivities(opts?: {
+    startToCloseTimeout?: string;
+}): _temporalio_workflow.ActivityInterfaceFor<EngineActivities>;
+declare function engineAgent(opts?: {
+    startToCloseTimeout?: string;
+}): _temporalio_workflow.ActivityInterfaceFor<EngineActivities>;
+declare function childDevCycle(input: TaskInput): Promise<DevCycleState>;
+declare const interceptors: WorkflowInterceptorsFactory;
+
+export { childDevCycle, engineActivities, engineAgent, interceptors };

package/dist/workflow.d.ts

@@ -0,0 +1,16 @@
+import * as _temporalio_workflow from '@temporalio/workflow';
+import { WorkflowInterceptorsFactory } from '@temporalio/workflow';
+import { TaskInput, DevCycleState, EngineActivities } from '@agentops/contracts';
+export { ENGINE_QUEUE, EngineActivities } from '@agentops/contracts';
+export { parseFindings, parseVerdict } from '@agentops/policies';
+
+declare function engineActivities(opts?: {
+    startToCloseTimeout?: string;
+}): _temporalio_workflow.ActivityInterfaceFor<EngineActivities>;
+declare function engineAgent(opts?: {
+    startToCloseTimeout?: string;
+}): _temporalio_workflow.ActivityInterfaceFor<EngineActivities>;
+declare function childDevCycle(input: TaskInput): Promise<DevCycleState>;
+declare const interceptors: WorkflowInterceptorsFactory;
+
+export { childDevCycle, engineActivities, engineAgent, interceptors };