@agentic-ops/engine-sdk 0.1.0

package/dist/workflow.js

@@ -0,0 +1,634 @@
+import "./chunk-3RG5ZIWI.js";
+
+// src/workflow.ts
+import { proxyActivities, executeChild, workflowInfo } from "@temporalio/workflow";
+import { defaultPayloadConverter } from "@temporalio/common";
+
+// ../contracts/src/stage.ts
+import { z } from "zod";
+var StageSchema = z.enum([
+  "context",
+  "assess",
+  "design",
+  "plan",
+  "implement",
+  "full_verify",
+  "review",
+  "pr",
+  "pr_babysit",
+  "done",
+  "failed",
+  "platform",
+  "bughunt",
+  "agent"
+]);
+var TaskStatusSchema = z.enum(["pending", "running", "blocked", "done", "failed"]);
+var BlockReasonSchema = 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
+import { z as z2 } from "zod";
+var ModelRefSchema = z2.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: z2.enum(["claude", "cursor", "pi", "codex", "stub", "litellm"]),
+  model: z2.string().min(1),
+  effort: z2.enum(["low", "medium", "high", "xhigh", "max"]).optional()
+});
+var BrakesSchema = z2.object({
+  maxImplementAttempts: z2.number().int().positive().default(3),
+  maxIterations: z2.number().int().positive(),
+  maxTokens: z2.number().int().positive(),
+  maxBabysitRounds: z2.number().int().positive()
+});
+var RoutingSchema = z2.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 = z2.object({
+  idleTimeoutMs: z2.number().int().positive().optional(),
+  timeoutMs: z2.number().int().positive().optional()
+});
+var TimeoutsSchema = z2.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 = z2.object({
+  assess: z2.boolean().optional(),
+  triage: z2.boolean().optional()
+});
+
+// ../contracts/src/project-config.ts
+import { z as z3, ZodError } from "zod";
+var VerifyServiceReadinessSchema = z3.discriminatedUnion("type", [
+  z3.object({ type: z3.literal("exec"), command: z3.array(z3.string()).min(1) }),
+  z3.object({ type: z3.literal("tcpSocket"), port: z3.number().int().positive() })
+]);
+var VerifyServiceSchema = z3.object({
+  name: z3.string().min(1),
+  image: z3.string().min(1),
+  env: z3.record(z3.string(), z3.string()).optional(),
+  readiness: VerifyServiceReadinessSchema
+});
+var ProjectConfigSchema = z3.object({
+  image: z3.string().min(1).optional(),
+  services: z3.array(VerifyServiceSchema).optional(),
+  initCommands: z3.array(z3.string()).optional(),
+  fastVerifyCommands: z3.array(z3.string()).optional(),
+  fullVerifyCommands: z3.array(z3.string()).optional(),
+  stages: StageToggleSchema,
+  routing: RoutingSchema,
+  escalation: ModelRefSchema.optional(),
+  brakes: BrakesSchema,
+  timeouts: TimeoutsSchema.optional()
+});
+
+// ../contracts/src/task-input.ts
+import { z as z4 } from "zod";
+var TaskInputSchema = z4.object({
+  taskId: z4.string().min(1),
+  project: z4.string().min(1),
+  repo: z4.string().min(1),
+  issueRef: z4.string().optional(),
+  goal: z4.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
+import { z as z5 } from "zod";
+var DevCycleStateSchema = z5.object({
+  taskId: z5.string().min(1),
+  stage: StageSchema,
+  status: TaskStatusSchema,
+  blockReason: BlockReasonSchema.nullable(),
+  implementAttempts: z5.number().int().nonnegative(),
+  iterations: z5.number().int().nonnegative(),
+  cumulativeTokens: z5.number().int().nonnegative(),
+  babysitRounds: z5.number().int().nonnegative(),
+  prRef: z5.string().nullable(),
+  workspaceRef: z5.string(),
+  branch: z5.string()
+});
+
+// ../contracts/src/stage-result.ts
+import { z as z6 } from "zod";
+var StageSourceSchema = z6.enum(["agent", "human", "triage"]);
+var StageOutcomeSchema = z6.enum(["pass", "fail", "unparseable", "skipped"]);
+var StageResultSchema = z6.object({
+  stage: StageSchema,
+  source: StageSourceSchema,
+  contentHash: z6.string().min(1),
+  tokens: z6.number().int().nonnegative(),
+  outcome: StageOutcomeSchema
+});
+
+// ../contracts/src/verdict.ts
+import { z as z7 } from "zod";
+var VerdictKindSchema = z7.enum(["pass", "fail", "unparseable"]);
+var VerdictSchema = z7.object({
+  kind: VerdictKindSchema,
+  findings: z7.array(z7.string()).optional()
+});
+
+// ../contracts/src/agent-run.ts
+import { z as z8 } from "zod";
+var AgentRunLimitsSchema = z8.object({
+  maxTokens: z8.number().int().positive(),
+  idleTimeoutMs: z8.number().int().positive().optional(),
+  timeoutMs: z8.number().int().positive()
+});
+var EffortSchema = z8.enum(["low", "medium", "high", "xhigh", "max"]);
+var AgentRunRequestSchema = z8.object({
+  taskId: z8.string().min(1),
+  stage: StageSchema,
+  attempt: z8.number().int().positive(),
+  callIndex: z8.number().int().positive().default(1),
+  backend: z8.string().min(1),
+  model: z8.string().min(1),
+  effort: EffortSchema.optional(),
+  image: z8.string().min(1).optional(),
+  services: z8.array(VerifyServiceSchema).optional(),
+  promptRef: z8.string().min(1),
+  promptContext: z8.record(z8.string(), z8.unknown()).default({}),
+  promptSource: z8.object({ repo: z8.string().min(1), commit: z8.string().min(1), path: z8.string().min(1) }).optional(),
+  workspaceRef: z8.string().min(1),
+  limits: AgentRunLimitsSchema
+});
+var BackendRunRequestSchema = AgentRunRequestSchema.omit({ promptRef: true, promptContext: true }).extend({
+  prompt: z8.string().min(1)
+});
+var AgentRunResultSchema = z8.object({
+  output: z8.string(),
+  tokensIn: z8.number().int().nonnegative(),
+  tokensOut: z8.number().int().nonnegative(),
+  wallMs: z8.number().int().nonnegative()
+});
+
+// ../contracts/src/run-stats.ts
+import { z as z9 } from "zod";
+var RunStatsSchema = z9.object({
+  taskId: z9.string().min(1),
+  stage: StageSchema,
+  backend: z9.string().min(1),
+  model: z9.string().min(1),
+  tokensIn: z9.number().int().nonnegative(),
+  tokensOut: z9.number().int().nonnegative(),
+  wallMs: z9.number().int().nonnegative(),
+  outcome: StageOutcomeSchema,
+  // provenance + attribution (design §7) — optional so existing call sites compile
+  promptHash: z9.string().optional(),
+  promptSource: z9.string().optional(),
+  project: z9.string().optional(),
+  workflowType: z9.string().optional()
+});
+
+// ../contracts/src/pr-feedback.ts
+import { z as z10 } from "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 = z10.enum(["pending", "green", "failed"]);
+var PrCommentSchema = z10.object({
+  id: z10.string().min(1),
+  body: z10.string(),
+  resolved: z10.boolean()
+});
+var PrFeedbackSchema = z10.object({
+  ciStatus: CiStatusSchema,
+  unresolvedThreads: z10.number().int().nonnegative(),
+  comments: z10.array(PrCommentSchema)
+});
+
+// ../contracts/src/managed-project.ts
+import { z as z11 } from "zod";
+var BaseManagedProjectFields = {
+  id: z11.string().uuid(),
+  project: z11.string().min(1),
+  repo: z11.string().min(1),
+  credentialSet: z11.boolean(),
+  // GitHub token set? never the token itself
+  config: ProjectConfigSchema.nullable(),
+  createdAt: z11.string(),
+  updatedAt: z11.string()
+};
+var ManagedProjectSchema = z11.discriminatedUnion("trackerType", [
+  z11.object({ ...BaseManagedProjectFields, trackerType: z11.literal("github") }),
+  z11.object({
+    ...BaseManagedProjectFields,
+    trackerType: z11.literal("linear"),
+    linearTeamKey: z11.string().min(1),
+    linearTriggerLabelId: z11.string().min(1),
+    linearCredentialSet: z11.boolean()
+    // Linear token set? never the token itself
+  })
+]);
+var UpsertManagedProjectRequestSchema = z11.object({
+  project: z11.string().min(1),
+  repo: z11.string().min(1),
+  token: z11.string().min(1).optional(),
+  config: ProjectConfigSchema.nullable().optional(),
+  trackerType: z11.enum(["github", "linear"]).default("github"),
+  linearTeamKey: z11.string().min(1).optional(),
+  linearTriggerLabelId: z11.string().min(1).optional(),
+  linearToken: z11.string().min(1).optional()
+});
+
+// ../contracts/src/platform-agent.ts
+import { z as z12 } from "zod";
+var ProposedFixSchema = z12.object({
+  repo: z12.string().min(1),
+  goal: z12.string().min(1)
+});
+var SkippedFixSchema = ProposedFixSchema.extend({
+  reason: z12.string().min(1)
+});
+var PlatformActionSchema = z12.object({
+  type: z12.enum(["terminate", "signal"]),
+  workflowId: z12.string().min(1),
+  reason: z12.string().min(1)
+});
+var PlatformSentinelSchema = z12.object({
+  summary: z12.string().min(1),
+  actionsTaken: z12.array(PlatformActionSchema).default([]),
+  proposedFixes: z12.array(ProposedFixSchema).default([])
+});
+var PlatformAgentInputSchema = z12.object({
+  prompt: z12.string().min(1),
+  hintRepos: z12.array(z12.string()).optional()
+});
+var PlatformAgentResultSchema = z12.object({
+  summary: z12.string(),
+  actionsTaken: z12.array(PlatformActionSchema).default([]),
+  childWorkflows: z12.array(
+    z12.object({
+      workflowId: z12.string().min(1),
+      repo: z12.string().min(1),
+      goal: z12.string().min(1)
+    })
+  ).default([]),
+  skippedFixes: z12.array(SkippedFixSchema).default([])
+});
+
+// ../contracts/src/control-api.ts
+import { z as z13 } from "zod";
+var StartRunRequestSchema = z13.object({
+  prompt: z13.string().min(1),
+  hintRepos: z13.array(z13.string()).optional(),
+  workflowId: z13.string().min(1).optional()
+});
+var StartRunResponseSchema = z13.object({
+  workflowId: z13.string().min(1),
+  runId: z13.string().min(1)
+});
+var RunStatusSchema = z13.enum([
+  "RUNNING",
+  "COMPLETED",
+  "FAILED",
+  "CANCELLED",
+  "TERMINATED",
+  "TIMED_OUT",
+  "CONTINUED_AS_NEW"
+]);
+var RunListItemSchema = z13.object({
+  workflowId: z13.string().min(1),
+  runId: z13.string().min(1),
+  status: RunStatusSchema,
+  startTime: z13.string().min(1),
+  closeTime: z13.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: z13.string().min(1).optional()
+});
+var RunDetailSchema = z13.object({
+  workflowId: z13.string().min(1),
+  runId: z13.string().min(1),
+  status: RunStatusSchema,
+  prompt: z13.string().min(1).optional(),
+  result: PlatformAgentResultSchema.optional(),
+  error: z13.string().min(1).optional(),
+  temporalUrl: z13.string().min(1)
+});
+var RepoListResponseSchema = z13.object({
+  repos: z13.array(z13.string())
+});
+
+// ../contracts/src/control-devcycle-api.ts
+import { z as z14 } from "zod";
+var StartDevCycleRequestSchema = z14.object({
+  repo: z14.string().min(1),
+  // owner/repo -- must resolve to a registered project (422 otherwise)
+  prompt: z14.string().min(1),
+  // becomes TaskInput.goal verbatim
+  taskId: z14.string().min(1).optional()
+  // default: randomUUID() in control
+});
+var StartDevCycleResponseSchema = z14.object({
+  workflowId: z14.string().min(1),
+  runId: z14.string().min(1),
+  taskId: z14.string().min(1)
+});
+var DevCycleRunDetailSchema = z14.object({
+  workflowId: z14.string().min(1),
+  runId: z14.string().min(1),
+  status: RunStatusSchema,
+  prompt: z14.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: z14.string().min(1).optional(),
+  temporalUrl: z14.string().min(1)
+});
+var DevCycleTargetSchema = z14.object({
+  repo: z14.string().min(1),
+  project: z14.string().min(1)
+});
+var DevCycleTargetsResponseSchema = z14.object({
+  targets: z14.array(DevCycleTargetSchema)
+});
+
+// ../contracts/src/control-projects-api.ts
+import { z as z15 } from "zod";
+var CreateManagedProjectRequestSchema = z15.object({
+  project: z15.string().min(1),
+  repo: z15.string().min(1),
+  token: z15.string().min(1),
+  config: ProjectConfigSchema.nullable().optional(),
+  trackerType: z15.enum(["github", "linear"]).default("github"),
+  linearTeamKey: z15.string().min(1).optional(),
+  linearTriggerLabelId: z15.string().min(1).optional(),
+  linearToken: z15.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 = z15.object({
+  token: z15.string().min(1).optional(),
+  config: ProjectConfigSchema.nullable().optional(),
+  linearTeamKey: z15.string().min(1).optional(),
+  linearTriggerLabelId: z15.string().min(1).optional(),
+  linearToken: z15.string().min(1).optional()
+});
+var ManagedProjectListResponseSchema = z15.array(ManagedProjectSchema);
+
+// ../contracts/src/control-agents-api.ts
+import { z as z16 } from "zod";
+var AgentScheduleSummarySchema = z16.object({
+  scheduleId: z16.string().min(1),
+  project: z16.string().min(1),
+  agentName: z16.string().min(1),
+  workflow: z16.string().min(1),
+  cron: z16.string().min(1),
+  paused: z16.boolean(),
+  nextRun: z16.string().optional()
+});
+var ListAgentSchedulesResponseSchema = z16.object({
+  agents: z16.array(AgentScheduleSummarySchema)
+});
+var TriggerAgentResponseSchema = z16.object({
+  scheduleId: z16.string().min(1),
+  triggered: z16.boolean()
+});
+
+// ../contracts/src/agents-manifest.ts
+import { z as z17, ZodError as ZodError2 } from "zod";
+var CRON_FIELD = String.raw`[\d*/,\-A-Za-z?]+`;
+var CRON_RE = new RegExp(`^${CRON_FIELD}(\\s+${CRON_FIELD}){4}$`);
+var scheduleSchema = z17.union([z17.literal("continuous"), z17.string().regex(CRON_RE, 'must be a 5-field cron or "continuous"')]);
+var AgentSpecSchema = z17.object({
+  name: z17.string().regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, "name must be kebab-case DNS-safe"),
+  workflow: z17.string().min(1),
+  schedule: scheduleSchema,
+  input: z17.record(z17.string(), z17.unknown()).default({}),
+  enabled: z17.boolean().default(true),
+  timezone: z17.string().default("UTC"),
+  overlap: z17.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: z17.string().min(1).optional()
+}).strict();
+var AgentsManifestSchema = z17.object({ agents: z17.array(AgentSpecSchema) }).strict();
+var WhiteboxBugHuntManifestInputSchema = z17.object({ focus: z17.string().optional() }).strict();
+
+// ../contracts/src/whitebox-finding.ts
+import { z as z18 } from "zod";
+var WhiteboxFindingSchema = z18.object({
+  title: z18.string().min(1),
+  detail: z18.string().min(1),
+  severity: z18.enum(["low", "medium", "high", "critical"]),
+  location: z18.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
+import { z as z19 } from "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 proxyActivities({ taskQueue: ENGINE_QUEUE, startToCloseTimeout: opts.startToCloseTimeout ?? "10m" });
+}
+function engineAgent(opts = {}) {
+  return proxyActivities({ taskQueue: ENGINE_QUEUE, startToCloseTimeout: opts.startToCloseTimeout ?? "1h" });
+}
+function childDevCycle(input) {
+  return executeChild("devCycle", { taskQueue: ENGINE_QUEUE, args: [input] });
+}
+var ProjectOutbound = class {
+  project() {
+    return readProjectFromMemo(workflowInfo().memo);
+  }
+  async scheduleActivity(input, next) {
+    const p = this.project();
+    if (p) input.headers = { ...input.headers, [PROJECT_HEADER_KEY]: defaultPayloadConverter.toPayload(p) };
+    return next(input);
+  }
+  async startChildWorkflowExecution(input, next) {
+    const p = this.project();
+    if (p) {
+      input.headers = { ...input.headers, [PROJECT_HEADER_KEY]: 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()] });
+export {
+  ENGINE_QUEUE,
+  childDevCycle,
+  engineActivities,
+  engineAgent,
+  interceptors,
+  parseFindings,
+  parseVerdict
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@agentic-ops/engine-sdk",
+  "version": "0.1.0",
+  "description": "Thin, secret-free facade for authoring Tier-2 agentops project workflows.",
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./workflow": {
+      "types": "./dist/workflow.d.ts",
+      "import": "./dist/workflow.js",
+      "require": "./dist/workflow.cjs"
+    },
+    "./worker": {
+      "types": "./dist/worker.d.ts",
+      "import": "./dist/worker.js",
+      "require": "./dist/worker.cjs"
+    }
+  },
+  "peerDependencies": {
+    "@temporalio/workflow": "*",
+    "@temporalio/worker": "*",
+    "@temporalio/common": "*",
+    "@temporalio/client": "*"
+  },
+  "dependencies": {
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9",
+    "@agentops/contracts": "0.0.0",
+    "@agentops/policies": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}