@kitman-sh/cli 0.7.5 → 0.8.0

package/dist/{chunk-a44szh8v.js → chunk-2npvts4c.js}

@@ -64,6 +64,8 @@ import {
   transform,
   encodeBase64Url,
   decodeBase64UrlString,
+  transform2,
+  declare,
   decodeUnknownEffect,
   decodeEffect,
   decodeSync,
@@ -76,6 +78,7 @@ import {
   Literal,
   Never,
   Unknown,
+  Null,
   String2,
   Boolean2,
   Void,
@@ -83,24 +86,237 @@ import {
   Record,
   Tuple,
   ArraySchema,
+  NonEmptyArray,
   Union,
   Literals,
   decodeTo,
   tag,
   makeFilter,
+  isPattern,
   Finite,
+  isGreaterThanOrEqualTo,
+  isLessThanOrEqualTo2,
   Int,
+  isMinLength,
+  isMaxLength,
   Defect,
   fromJsonString,
   Cause,
   Exit,
   Class,
   TaggedError2,
+  toEquivalence,
   toJsonSchemaDocument,
   toCodecJson,
   Json,
-  LoopCapabilities
-} from "./chunk-p2wk2v39.js";
+  guard,
+  SafeJson,
+  relativePathPattern,
+  skillNamePattern,
+  AgentSandboxNetwork,
+  AgentEfforts,
+  LoopDataSchemaRef,
+  ProgramLoop,
+  KitKinds
+} from "./chunk-fpyy4rpd.js";
+
+// packages/core/src/schedule.ts
+var ScheduleFrequency = ["daily", "weekly"];
+var ScheduleMisfirePolicies = ["skip", "fire_once", "catch_up"];
+var ScheduleOverlapPolicies = ["allow", "skip", "coalesce"];
+var ScheduleVersionStatuses = ["draft", "published", "disabled", "archived"];
+var ScheduleCalendarRule = Struct({
+  frequency: Literals(ScheduleFrequency),
+  hour: Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(23)),
+  minute: Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(59)),
+  second: optionalKey(Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(59))),
+  daysOfWeek: optionalKey(ArraySchema(Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(6))).check(isMinLength(1), isMaxLength(7)))
+});
+var ScheduleCronRule = Struct({
+  cron: String2.check(isMinLength(9), isMaxLength(200), isPattern(new RegExp("^[0-9*,/-]+( [0-9*,/-]+){4}$", "u")))
+});
+var ScheduleRule = Union([ScheduleCalendarRule, ScheduleCronRule]);
+var cronBounds = [
+  [0, 59],
+  [0, 23],
+  [1, 31],
+  [1, 12],
+  [0, 7]
+];
+function cronField(field, [min, max]) {
+  const values = new Set;
+  for (const part of field.split(",")) {
+    const match = /^(\*|(\d+)(?:-(\d+))?)(?:\/(\d+))?$/.exec(part);
+    if (match === null)
+      return;
+    const from = match[1] === "*" ? min : Number(match[2]);
+    const to = match[1] === "*" ? max : match[3] === undefined ? match[4] === undefined ? from : max : Number(match[3]);
+    const step = match[4] === undefined ? 1 : Number(match[4]);
+    if (from < min || to > max || from > to || step < 1)
+      return;
+    for (let value = from;value <= to; value += step)
+      values.add(value);
+  }
+  return values;
+}
+function parseCron(cron) {
+  const fields = cron.split(" ");
+  const [minutes, hours, days, months, weekdays] = fields.map((field, index) => cronField(field, cronBounds[index] ?? [0, 0]));
+  if (fields.length !== 5 || !minutes || !hours || !days || !months || !weekdays)
+    return;
+  return {
+    minutes,
+    hours,
+    days,
+    months,
+    weekdays: new Set([...weekdays].map((value) => value % 7)),
+    dayRestricted: !(fields[2] ?? "").startsWith("*"),
+    weekdayRestricted: !(fields[4] ?? "").startsWith("*")
+  };
+}
+function isScheduleRule(value) {
+  return guard(ScheduleRule)(value) && (!("cron" in value) || parseCron(value.cron) !== undefined);
+}
+var ScheduleVersion = Struct({
+  contractVersion: Literal("schedule.v1"),
+  id: String2.check(isMinLength(1)),
+  scheduleId: String2.check(isMinLength(1)),
+  workspaceId: String2.check(isMinLength(1)),
+  teamId: optionalKey(String2.check(isMinLength(1))),
+  loopId: optionalKey(String2.check(isMinLength(1))),
+  name: optionalKey(String2.check(isMinLength(1), isMaxLength(200))),
+  version: Int.check(isGreaterThanOrEqualTo(1)),
+  status: Literals(ScheduleVersionStatuses),
+  timezone: String2.check(isMinLength(1), isMaxLength(80)),
+  rule: ScheduleRule,
+  misfirePolicy: Literals(ScheduleMisfirePolicies),
+  overlapPolicy: Literals(ScheduleOverlapPolicies),
+  maxCatchUp: Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(200)),
+  misfireGraceSeconds: optionalKey(Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(604800))),
+  inputSchemaRef: optionalKey(LoopDataSchemaRef),
+  input: optionalKey(SafeJson),
+  createdAt: String2.check(isMinLength(1))
+});
+var zones = new Map;
+var resolvedLocalDateTimes = new Map;
+
+// packages/core/src/package-declarations.ts
+var LoopCapabilities = [
+  "agent_work",
+  "ask",
+  "call",
+  "verify",
+  "change_request",
+  "write_back",
+  "post_comment",
+  "create_tasks",
+  "merge_change_request",
+  "publish_release",
+  "read_transcripts",
+  "propose",
+  "read_project",
+  "draft_update"
+];
+var JsonObject = Record(String2, Json);
+var recordKeyedBy = (pattern, value) => Record(String2, value).check(makeFilter((record) => {
+  const bad = Object.keys(record).find((key) => !new RegExp(pattern).test(key));
+  return bad === undefined ? true : `${JSON.stringify(bad)} is not a valid name or relative path`;
+}));
+var SecretName = String2.check(isPattern(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/));
+var EventFilterValue = Union([String2, Finite, Boolean2, Null]);
+var LoopManifest = Struct({
+  id: String2,
+  title: String2,
+  input: JsonObject,
+  output: JsonObject,
+  outcome: optionalKey(Literals(["feature", "bug", "refactor", "investigation", "docs", "migration"])),
+  agents: Record(String2, String2),
+  checkout: Literals(["none", "read", "write"]),
+  when: ArraySchema(Struct({
+    event: String2,
+    filter: optionalKey(Record(String2, Union([EventFilterValue, ArraySchema(EventFilterValue)]))),
+    input: Record(String2, String2)
+  })),
+  offers: ArraySchema(Struct({ id: String2, title: String2, loop: String2 })),
+  capabilities: ArraySchema(Literals(LoopCapabilities)),
+  secrets: optionalKey(ArraySchema(SecretName)),
+  network: optionalKey(AgentSandboxNetwork),
+  schedule: optionalKey(Struct({ rule: ScheduleRule, timezone: String2 }))
+});
+var LoopDetail = Struct({
+  id: String2,
+  resolved: optionalKey(Struct({
+    ...ProgramLoop.fields,
+    agents: LoopManifest.fields.agents,
+    when: LoopManifest.fields.when,
+    schedule: optionalKey(Struct({
+      rule: ScheduleRule,
+      timezone: String2,
+      on: Boolean2,
+      nextRunAt: optionalKey(String2)
+    }))
+  }))
+});
+var AgentDeclaration = Struct({
+  extends: optionalKey(String2),
+  instructions: optionalKey(String2),
+  harness: optionalKey(String2),
+  model: optionalKey(String2),
+  effort: optionalKey(Literals(AgentEfforts)),
+  kits: optionalKey(ArraySchema(String2)),
+  network: optionalKey(Union([Struct({ hosts: ArraySchema(String2) }), Literal("open")])),
+  sandbox: optionalKey(Literal("docker"))
+});
+var scheduleFields = {
+  name: String2.check(isMinLength(1)),
+  loop: String2,
+  team: optionalKey(String2),
+  input: optionalKey(JsonObject),
+  timezone: String2,
+  misfire: optionalKey(Literals(ScheduleMisfirePolicies)),
+  overlap: optionalKey(Literals(ScheduleOverlapPolicies))
+};
+var ScheduleDeclaration = Union([
+  Struct({
+    ...scheduleFields,
+    cron: String2.check(makeFilter((cron) => isScheduleRule({ cron }) || "five cron fields, each within its range"))
+  }),
+  Struct({
+    ...scheduleFields,
+    rule: declare((value) => isScheduleRule(value), {
+      expected: "a Schedule rule: frequency daily or weekly, hour, minute, and optionally second and daysOfWeek"
+    })
+  })
+]);
+var AuthoredKitDeclaration = Struct({
+  name: String2.check(isMinLength(1)),
+  kind: optionalKey(Literals(KitKinds)),
+  description: optionalKey(String2),
+  context: String2,
+  skills: optionalKey(recordKeyedBy(skillNamePattern, recordKeyedBy(relativePathPattern, String2)))
+});
+var KitInstallationDeclaration = Struct({
+  source: String2.check(isMinLength(1)),
+  version: optionalKey(String2)
+});
+var KitAssignmentDeclaration = Struct({
+  kit: String2.check(isMinLength(1)),
+  workspace: optionalKey(Literals(["default", "mandatory"])),
+  teams: optionalKey(ArraySchema(String2))
+});
+var KitDeclaration = Union([
+  KitInstallationDeclaration,
+  KitAssignmentDeclaration,
+  AuthoredKitDeclaration
+]);
+var PackageDeclarations = Struct({
+  loops: ArraySchema(LoopManifest),
+  agents: Record(String2, AgentDeclaration),
+  schedules: optionalKey(Record(String2, ScheduleDeclaration)),
+  kits: optionalKey(Record(String2, KitDeclaration))
+});
+var sameLoop = toEquivalence(LoopManifest);
+var sameAgent = toEquivalence(AgentDeclaration);
 
 // packages/sdk/src/loop/define.ts
 var LoopOutcome = Literals(["feature", "bug", "refactor", "investigation", "docs", "migration"]);
@@ -754,11 +970,17 @@ var WriteBackRequest = Struct({
   milestone: optional(Literals(WriteBackMilestones)),
   changeRequestUrl: optional(String2)
 });
+var RunFile = Struct({ runFile: String2 }).pipe(decodeTo(Struct({ id: String2 }), transform2({
+  decode: ({ runFile }) => ({ id: runFile }),
+  encode: ({ id }) => ({ runFile: id })
+})));
+var FileRequest = Struct({ path: String2, caption: optional(String2) });
 var ArtifactRequest = Struct({
   kind: String2,
   title: String2,
   text: String2,
-  data: optional(Json)
+  data: optional(Json),
+  files: optional(ArraySchema(RunFile))
 });
 var ArtifactResult = Struct({ artifactId: String2 });
 var NoteRequest = Struct({ text: String2, artifactId: optional(String2) });
@@ -785,6 +1007,68 @@ var ReleaseRequest = Struct({
   notes: String2
 });
 var ReleaseResult = Struct({ tag: String2, revision: String2, url: String2 });
+var TranscriptPoint = Struct({
+  runId: String2,
+  stepAttemptId: String2,
+  sequence: Int
+});
+var TranscriptsRequest = Struct({
+  days: Int.check(isGreaterThanOrEqualTo(1), isLessThanOrEqualTo2(31))
+});
+var TranscriptsResult = Struct({
+  runs: ArraySchema(Struct({
+    runId: String2,
+    loopId: String2,
+    teamId: optional(String2),
+    failure: optional(String2),
+    entries: ArraySchema(Struct({ stepAttemptId: String2, sequence: Int, kind: String2, text: String2 }))
+  }))
+});
+var Citations = NonEmptyArray(TranscriptPoint);
+var ProposeRequest = Union([
+  Struct({
+    kind: Literal("memory"),
+    teamId: String2,
+    content: String2,
+    citations: Citations
+  }),
+  Struct({
+    kind: Literal("task"),
+    title: String2,
+    description: String2,
+    teamId: optional(String2),
+    citations: Citations
+  })
+]);
+var ProposeResult = Struct({ kind: Literals(["memory", "task"]), id: String2 });
+var Health = Literals(["on_track", "at_risk", "off_track"]);
+var ProjectActivityRequest = Struct({ projectId: String2 });
+var ProjectActivityResult = Struct({
+  project: Struct({ id: String2, name: String2 }),
+  health: optional(Health),
+  since: optional(String2),
+  runs: ArraySchema(Struct({
+    runId: String2,
+    loopId: String2,
+    status: String2,
+    taskKey: optional(String2),
+    taskTitle: optional(String2),
+    summary: optional(String2),
+    entries: ArraySchema(Struct({ stepAttemptId: String2, sequence: Int, kind: String2, text: String2 }))
+  })),
+  taskChanges: ArraySchema(Struct({ taskKey: String2, title: String2, change: String2, at: String2 }))
+});
+var DraftUpdateRequest = Struct({
+  projectId: String2,
+  health: Health,
+  note: String2,
+  writtenFrom: Struct({
+    runs: Int,
+    taskChanges: Int,
+    since: optional(String2)
+  })
+});
+var DraftUpdateResult = Struct({ id: String2 });
 
 class ChangeRequestActivity extends Service()("@kitman-sh/sdk/loop/ChangeRequestActivity") {
 }
@@ -795,6 +1079,9 @@ class WriteBackActivity extends Service()("@kitman-sh/sdk/loop/WriteBackActivity
 class ArtifactActivity extends Service()("@kitman-sh/sdk/loop/ArtifactActivity") {
 }
 
+class FileActivity extends Service()("@kitman-sh/sdk/loop/FileActivity") {
+}
+
 class NoteActivity extends Service()("@kitman-sh/sdk/loop/NoteActivity") {
 }
 
@@ -812,6 +1099,18 @@ class MergeChangeRequestActivity extends Service()("@kitman-sh/sdk/loop/MergeCha
 
 class ReleaseActivity extends Service()("@kitman-sh/sdk/loop/ReleaseActivity") {
 }
+
+class TranscriptsActivity extends Service()("@kitman-sh/sdk/loop/TranscriptsActivity") {
+}
+
+class ProposeActivity extends Service()("@kitman-sh/sdk/loop/ProposeActivity") {
+}
+
+class ProjectActivityActivity extends Service()("@kitman-sh/sdk/loop/ProjectActivityActivity") {
+}
+
+class DraftUpdateActivity extends Service()("@kitman-sh/sdk/loop/DraftUpdateActivity") {
+}
 var hostActivity = (name, kind, capability, success, execute) => takeStep(name, kind, capability, make3({ name: `${kind}/${name}`, success, error: StepFailed, execute }));
 var changeRequest = (name, request) => hostActivity(name, "change_request", "change_request", ChangeRequestResult, gen(function* () {
   return yield* (yield* ChangeRequestActivity).run(request, name);
@@ -840,6 +1139,18 @@ var mergeChangeRequest = (name, request) => hostActivity(name, "merge_change_req
 var release2 = (name, request) => hostActivity(name, "release", "publish_release", ReleaseResult, gen(function* () {
   return yield* (yield* ReleaseActivity).run(request, name);
 }));
+var transcripts = (name, request) => hostActivity(name, "transcripts", "read_transcripts", TranscriptsResult, gen(function* () {
+  return yield* (yield* TranscriptsActivity).run(request, name);
+}));
+var propose = (name, request) => hostActivity(name, "propose", "propose", ProposeResult, gen(function* () {
+  return yield* (yield* ProposeActivity).run(request, name);
+}));
+var projectActivity = (name, request) => hostActivity(name, "project_activity", "read_project", ProjectActivityResult, gen(function* () {
+  return yield* (yield* ProjectActivityActivity).run(request, name);
+}));
+var draftUpdate = (name, request) => hostActivity(name, "draft_update", "draft_update", DraftUpdateResult, gen(function* () {
+  return yield* (yield* DraftUpdateActivity).run(request, name);
+}));
 // packages/sdk/src/loop/test-loop.ts
 var LoopJournal = Struct({
   activities: Record(String2, Json),
@@ -959,4 +1270,4 @@ class ReplayDiverged extends TaggedError2()("ReplayDiverged", {
   }
 }
 var LoopCheckError = Union([CheckFailed, StepNamedTwice, ReplayDiverged]);
-export { LoopOutcome, defineLoop, ManifestInvalid, make, Suspended, make2, await_, make3, evidenceGate, ChildFailed, agentWork, ask, call, waitFor, verify, PlanTickets, planWaves, ChangeRequestResult, CreateTasksResult, changeRequest, writeBack, artifact, note, comment, createTasks, integrationBranch, mergeChangeRequest, release2, Finding, MergedFinding, Rebuttal, RebuttalVerdict, ScopeJudgement, isBlocking, mergeFindings, settleRound, rallyStop, LoopCheckError };
+export { LoopManifest, AgentDeclaration, KitInstallationDeclaration, KitAssignmentDeclaration, PackageDeclarations, LoopOutcome, defineLoop, ManifestInvalid, make, Suspended, make2, await_, make3, evidenceGate, ChildFailed, agentWork, ask, call, waitFor, verify, PlanTickets, planWaves, ChangeRequestResult, CreateTasksResult, TranscriptPoint, changeRequest, writeBack, artifact, note, comment, createTasks, integrationBranch, mergeChangeRequest, release2, transcripts, propose, projectActivity, draftUpdate, Finding, MergedFinding, Rebuttal, RebuttalVerdict, ScopeJudgement, isBlocking, mergeFindings, settleRound, rallyStop, LoopCheckError };

package/dist/{chunk-0pre510a.js → chunk-64et31rh.js}

@@ -31,7 +31,7 @@ import {
   Int,
   TaggedError2,
   Json
-} from "./chunk-p2wk2v39.js";
+} from "./chunk-fpyy4rpd.js";
 import {
   LoopOutcome,
   defineLoop,
@@ -49,6 +49,7 @@ import {
   planWaves,
   ChangeRequestResult,
   CreateTasksResult,
+  TranscriptPoint,
   changeRequest,
   writeBack,
   artifact,
@@ -58,6 +59,10 @@ import {
   integrationBranch,
   mergeChangeRequest,
   release2,
+  transcripts,
+  propose,
+  projectActivity,
+  draftUpdate,
   Finding,
   MergedFinding,
   Rebuttal,
@@ -67,7 +72,7 @@ import {
   mergeFindings,
   settleRound,
   rallyStop
-} from "./chunk-a44szh8v.js";
+} from "./chunk-2npvts4c.js";
 
 // node_modules/.bun/effect@4.0.4/node_modules/effect/dist/workflow/DurableClock.js
 var TypeId = "~effect/workflow/DurableClock";
@@ -897,8 +902,53 @@ var plan_default = defineLoop({
   })
 });
 
+// packages/loops/src/project-update.ts
+var Health = Literals(["on_track", "at_risk", "off_track"]);
+var Input6 = Struct({ projectId: String2 });
+var Output6 = Struct({ draftId: String2, health: Health });
+var Written = Struct({
+  health: Health,
+  note: String2
+});
+var day = (iso) => new Date(iso).toLocaleDateString("en-US", { month: "short", day: "numeric", timeZone: "UTC" });
+var prompt = (read) => [
+  `Write a Project Update for ${read.project.name} from what happened ${read.since === undefined ? "so far" : `since its last Update on ${day(read.since)}`}.`,
+  "```json",
+  JSON.stringify({ health: read.health, runs: read.runs, taskChanges: read.taskChanges }, null, 2),
+  "```",
+  "Say in a few short paragraphs what moved, what is stuck and what comes next, naming Tasks by key. Suggest a health: on_track, at_risk or off_track. A person reviews and posts it, so claim nothing the Runs and Task changes do not show."
+].join(`
+`);
+var nothingNew = (read) => ({
+  health: read.health ?? "on_track",
+  note: read.since === undefined ? "No Runs or Task changes yet." : `No Runs or Task changes since the last Update on ${day(read.since)}.`
+});
+var project_update_default = defineLoop({
+  id: "project-update",
+  title: "Project update",
+  input: Input6,
+  output: Output6,
+  agents: { writer: "investigator" },
+  checkout: "none",
+  capabilities: ["read_project", "agent_work", "draft_update"],
+  run: ({ projectId }) => gen(function* () {
+    const read = yield* projectActivity("read", { projectId });
+    const written = read.runs.length === 0 && read.taskChanges.length === 0 ? nothingNew(read) : yield* agentWork("write", { agent: "writer", prompt: prompt(read), output: Written });
+    const draft = yield* draftUpdate("draft", {
+      projectId,
+      ...written,
+      writtenFrom: {
+        runs: read.runs.length,
+        taskChanges: read.taskChanges.length,
+        ...read.since === undefined ? undefined : { since: read.since }
+      }
+    });
+    return { draftId: draft.id, health: written.health };
+  })
+});
+
 // packages/loops/src/release.ts
-var Input6 = Struct({
+var Input7 = Struct({
   tag: optional(String2),
   revision: optional(String2),
   deployEvent: optional(String2),
@@ -910,7 +960,7 @@ var Drafted = Struct({
   notes: String2,
   changeRequests: ArraySchema(String2)
 });
-var Output6 = Union([
+var Output7 = Union([
   Struct({ status: Literal("rejected"), tag: String2, notesArtifactId: String2 }),
   Struct({
     status: Literals(["deployed", "deploy_failed", "timed_out"]),
@@ -935,8 +985,8 @@ var reports = {
 var release_default = defineLoop({
   id: "release",
   title: "Release",
-  input: Input6,
-  output: Output6,
+  input: Input7,
+  output: Output7,
   agents: { releaser: "releaser" },
   checkout: "read",
   capabilities: ["agent_work", "ask", "publish_release"],
@@ -983,7 +1033,7 @@ ${drafted.notes}`,
 });
 
 // packages/loops/src/research.ts
-var Input7 = Struct({
+var Input8 = Struct({
   taskId: String2,
   repoBindingId: optional(String2)
 });
@@ -996,8 +1046,8 @@ var Report = Struct({
   openQuestions: ArraySchema(String2),
   nextSteps: ArraySchema(String2)
 });
-var Output7 = Struct({ reportArtifactId: String2 });
-var prompt = [
+var Output8 = Struct({ reportArtifactId: String2 });
+var prompt2 = [
   "Research the question this Task asks, using the `research` skill. The Task's title, description, Acceptance Criteria and comments are in your context.",
   "Cite primary sources for every finding: the code, official documentation, specifications and first-party APIs. Say what you read or ran and what it showed; separate what you established from what you suspect.",
   "Return the report as your Output, with `title` set to the Task's title. Do not write it into the repository."
@@ -1038,15 +1088,15 @@ var sample = {
 var research_default = defineLoop({
   id: "research",
   title: "Research",
-  input: Input7,
-  output: Output7,
+  input: Input8,
+  output: Output8,
   outcome: "investigation",
   agents: { researcher: "researcher" },
   checkout: "read",
   capabilities: ["agent_work"],
   checks: [{ name: "reports", script: { input: { taskId: "task-1" }, outputs: { research: sample } } }],
   run: () => gen(function* () {
-    const report = yield* agentWork("research", { agent: "researcher", prompt, output: Report });
+    const report = yield* agentWork("research", { agent: "researcher", prompt: prompt2, output: Report });
     const { artifactId } = yield* artifact("report", {
       kind: "research_report",
       title: report.title,
@@ -1058,6 +1108,82 @@ var research_default = defineLoop({
   })
 });
 
+// packages/loops/src/retrospective.ts
+var Input9 = Struct({});
+var Proposal = Struct({
+  kind: Literals(["memory", "task"]),
+  id: String2,
+  runIds: ArraySchema(String2)
+});
+var Output9 = Struct({ proposals: ArraySchema(Proposal) });
+var Findings = Struct({
+  findings: ArraySchema(Struct({
+    kind: Literals(["memory", "task"]),
+    lesson: String2,
+    detail: optional(String2),
+    citations: ArraySchema(TranscriptPoint)
+  }))
+});
+var days = 7;
+var prompt3 = (read) => [
+  `These Runs failed in the last ${days} days. Find what keeps going wrong: the same mistake or failure in more than one Run.`,
+  "```json",
+  JSON.stringify(read.runs, null, 2),
+  "```",
+  "For each, propose Memory when agents can avoid it by knowing something, or a Task when something has to change. Cite every Transcript point (runId, stepAttemptId, sequence) it shows in. Leave out anything seen in one Run only."
+].join(`
+`);
+var point = (cited) => `${cited.runId}/${cited.stepAttemptId}/${cited.sequence}`;
+var shared = (cited, field) => {
+  const values = new Set(cited.map((run) => run[field]));
+  const [only] = values;
+  return values.size === 1 ? only : undefined;
+};
+var proposal = (finding, read) => {
+  const readPoints = new Set(read.runs.flatMap((run) => run.entries.map((entry) => point({ runId: run.runId, stepAttemptId: entry.stepAttemptId, sequence: entry.sequence }))));
+  const citations = [
+    ...new Map(finding.citations.filter((cited) => readPoints.has(point(cited))).map((cited) => [point(cited), cited])).values()
+  ];
+  const runIds = new Set(citations.map((cited) => cited.runId));
+  const [first, ...rest] = citations;
+  if (first === undefined || runIds.size < 2)
+    return;
+  const cited = read.runs.filter((run) => runIds.has(run.runId));
+  const teamId = shared(cited, "teamId");
+  if (finding.kind === "memory" && teamId !== undefined)
+    return { kind: "memory", teamId, content: finding.lesson, citations: [first, ...rest] };
+  return {
+    kind: "task",
+    title: finding.lesson,
+    description: finding.detail ?? finding.lesson,
+    ...teamId === undefined ? undefined : { teamId },
+    citations: [first, ...rest]
+  };
+};
+var retrospective_default = defineLoop({
+  id: "retrospective",
+  title: "Retrospective",
+  input: Input9,
+  output: Output9,
+  outcome: "investigation",
+  agents: { investigator: "investigator" },
+  checkout: "none",
+  schedule: { rule: { frequency: "weekly", daysOfWeek: [1], hour: 9, minute: 0 }, timezone: "UTC" },
+  capabilities: ["read_transcripts", "agent_work", "propose"],
+  run: () => gen(function* () {
+    const read = yield* transcripts("read", { days });
+    if (read.runs.length < 2)
+      return { proposals: [] };
+    const { findings } = yield* agentWork("find", { agent: "investigator", prompt: prompt3(read), output: Findings });
+    const requests = findings.flatMap((finding) => proposal(finding, read) ?? []);
+    const proposals = yield* forEach(requests, (request, index) => map3(propose(`propose-${index + 1}`, request), (made) => ({
+      ...made,
+      runIds: [...new Set(request.citations.map((cited) => cited.runId))]
+    })));
+    return { proposals };
+  })
+});
+
 // packages/loops/src/index.ts
 var shippedLoops = {
   build: build_default,
@@ -1066,8 +1192,10 @@ var shippedLoops = {
   hello: hello_default,
   incident: incident_default,
   plan: plan_default,
+  "project-update": project_update_default,
   release: release_default,
   research: research_default,
+  retrospective: retrospective_default,
   review: review_default
 };
 export {
@@ -1077,8 +1205,10 @@ export {
   hello_default as hello,
   incident_default as incident,
   plan_default as plan,
+  project_update_default as projectUpdate,
   release_default as release,
   research_default as research,
+  retrospective_default as retrospective,
   review_default as review,
   shippedLoops
 };