The framework to turn repetitive knowledge work into enterprise-ready agentic systems.

import { Workflow } from "@effect/workflow";
import { Human, Session, Workspace } from "@laufwerk/sdk";
import { Effect, Schema } from "effect";
import {
  execution,
  implementer,
  planner,
  reviewer,
} from "../../agents/factory";
import {
  branchFor,
  merge,
  prepareIssue,
  publish,
} from "../../tasks/factory";

export const Review = Schema.Struct({
  approved: Schema.Boolean,
  feedback: Schema.String,
});

export const workflow = Workflow.make({
  name: "issue-to-pr",
  payload: { issueNumber: Schema.Int.pipe(Schema.positive()) },
  success: Schema.String,
  error: Schema.String,
  idempotencyKey: ({ issueNumber }) => `laufwerk-issue-${issueNumber}`,
});

export const layer = workflow.toLayer((input) =>
  Effect.gen(function* () {
    const issue = yield* prepareIssue(input.issueNumber);

    const workspace = yield* Workspace.open({
      source: issue.source,
      execution,
    });

    const request = `${issue.url}\n${issue.title}\n\n${issue.body}`;

    const planning = yield* Session.open({
      key: "planner",
      agent: planner,
      workspace,
      access: "read-only",
    });

    let plan = yield* planning.ask({
      key: "draft",
      prompt: `Inspect the repository and plan this issue. Give concrete acceptance criteria, minimal implementation steps and verification.\n${request}`,
    });

    const planReview = yield* Session.run({
      key: "plan-review",
      agent: reviewer,
      workspace,
      access: "read-only",
      output: Review,
      prompt: `Review this plan against the actual source and issue. Identify missing requirements, duplicated mechanisms, unnecessary complexity and verification gaps.\nIssue: ${request}\nPlan: ${plan}`,
    });

    plan = yield* planning.ask({
      key: "revise",
      prompt: `Revise the plan once using this feedback (even if approved). Return the complete final plan and explicitly name unresolved disagreements.\n${planReview.feedback}`,
    });

    yield* planning.close();

    // Keep the implementer's context within a coding cycle; close it before human
    // suspension so idle approvals do not retain running containers indefinitely.
    let humanFeedback = "";

    for (let cycle = 0; ; cycle++) {
      const coding = yield* Session.open({
        key: `implementer-${cycle}`,
        agent: implementer,
        workspace,
        access: "read-write",
      });

      let feedback = humanFeedback || planReview.feedback;

      let summary = "";

      let reviewStatus = "";

      const passes = cycle === 0 ? 3 : 2;

      for (let pass = 1; pass <= passes; pass++) {
        summary = yield* coding.ask({
          key: `implement-${pass}`,
          prompt: `Implement this issue and plan. ${cycle > 0 ? "This revises the existing PR in response to the human." : ""}
Issue: ${request}\nPlan: ${plan}\nFeedback: ${feedback}
Inspect the current source, implement minimal changes and run relevant tests. Report what changed, evidence and limitations.`,
        });

        if (pass === passes) {
          reviewStatus = `The last implementation pass (${pass}) was not reviewed, as specified by the iteration limit. Previous review feedback: ${feedback}`;

          break;
        }

        const review = yield* Session.run({
          key: `code-review-${cycle}-${pass}`,
          agent: reviewer,
          workspace,
          access: "read-only",
          output: Review,
          prompt: `Independently inspect all changes against base ${issue.base} (including untracked files). Check the issue and final plan are fully implemented. Reject defects, unnecessary complexity, duplicate code, unrelated edits, weak tests or unsupported verification claims.
Issue: ${request}\nPlan: ${plan}\nHuman feedback: ${humanFeedback}\nImplementation report: ${summary}`,
        });

        reviewStatus = review.approved
          ? `Code review approved: ${review.feedback}`
          : `Code review rejected: ${review.feedback}`;

        if (review.approved) break;

        feedback = review.feedback;
      }

      // Required checks run in Docker and cannot execute repository code on the host.
      const check = yield* coding.exec({
        key: "verify",
        command:
          "bun install --frozen-lockfile && bun run check && bun run test:ci",
      });

      if (check.exitCode !== 0) {
        yield* coding.close();

        return yield* Effect.fail(
          `Required verification failed; nothing published.\n${check.stdout}\n${check.stderr}`,
        );
      }

      const branch = branchFor(issue.number);

      const exported = yield* coding.exec({
        key: "commit-and-export",
        command: `set -eu
[ "$(git branch --show-current)" = '${branch}' ]
git merge-base --is-ancestor '${issue.base}' HEAD
git -c core.hooksPath=/dev/null add -A
if ! git diff --cached --quiet; then
  git -c core.hooksPath=/dev/null -c user.name='Laufwerk Factory' -c user.email='factory@laufwerk.local' commit -m 'Implement issue #${issue.number} (revision ${cycle})' >&2
fi
[ "$(git rev-parse HEAD)" != '${issue.base}' ]
git bundle create /tmp/factory.bundle 'refs/heads/${branch}' '^${issue.base}' >&2
base64 -w0 /tmp/factory.bundle`,
      });

      yield* coding.close();

      if (exported.exitCode !== 0)
        return yield* Effect.fail(
          `Commit/export failed: ${exported.stderr}`,
        );

      const report = `${summary}\n\n${reviewStatus}\n\nRequired verification passed: bun run check; bun run test:ci.\n\n${cycle > 0 ? `Human feedback addressed:\n${humanFeedback}` : ""}`;

      const pr = yield* publish(
        issue,
        cycle,
        exported.stdout.trim(),
        report,
      );

      const approved = yield* Human.confirm({
        key: `approve-${cycle}`,
        title: `Review PR #${pr.number}`,
        description: `${pr.url}\nCommit: ${pr.sha}\n\n${report}\n\nApprove to squash-merge this exact commit. Reject to supply requested changes.`,
      });

      if (approved) return yield* merge(pr);

      humanFeedback = yield* Human.text({
        key: `feedback-${cycle}`,
        title: `Requested changes for PR #${pr.number}`,
        description: `${pr.url}\nDescribe what the implementer should change.`,
      });

      // Blank rejection must not start another paid coding cycle.
      for (let attempt = 1; !humanFeedback.trim(); attempt++) {
        humanFeedback = yield* Human.text({
          key: `feedback-${cycle}-required-${attempt}`,
          title: "Please describe the requested changes",
          description: pr.url,
        });
      }
    }
  }).pipe(Effect.mapError((error) => String(error))),
);