"note": "Heuristic false-green LEADS, not findings. A finding requires a demonstrated reproduction (surviving mutation via mutation-runner). Do not treat a candidate as a confirmed false green. Coverage-theater leads may include tests that delegate their assertion to a custom helper the classifier does not recognise; verify before acting.",

  "sourceDigest": "sha256:dd810dd48c5bdbc9becd7fcc01dd41a4ca2abf0b2d6f6a545907247f6e3e8361",

  "summary": {

    "filesScanned": 2458,

    "filesScanned": 2459,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:d492fe3229c64f1d4b8d114ab4ed45bef787f8e7fc2277927d6b9d60491c4ee2",

  "sourceDigest": "sha256:59b3aac646bddcbc39932e2474e2720da8c7ced4b3591d31a65725d1ec4f97df",

  "surfaces": [

    {

      "id": "app:@openagentsinc/acceptance-runner",

      "oracles": [

        {

          "type": "test",

          "ref": "packages/openagents-cli (58 tracked test files)"

          "ref": "packages/openagents-cli (59 tracked test files)"

        },

        {

          "type": "behavior-contract",

import type { AgentConfigEntry } from "./computer-config.js";

import { defaultCuratedExecute, type Tier, withinRoot } from "./computer-policy.js";

import { pushDelegated, type ForgeCredentials } from "./delegation-push.js";

import { VERSION } from "./version.js";

export type AgentCatalogSource = "local" | "configured" | "remote";

  readonly onChunk: (text: string) => void;

  readonly onSession: (sessionId: string) => void;

  readonly onPermission: (allowed: boolean, detail: string) => void;

  readonly forgeOrigin?: string;

  readonly forgeCredentials?: ForgeCredentials;

}

export interface AgentDelegationOutcome {

        ? { outcome: { outcome: "cancelled" } }

        : { outcome: { outcome: "selected", optionId: String(record(option).optionId ?? "") } };

    });

    const forgeCredentials = request.forgeCredentials;

    const forgeOrigin = request.forgeOrigin;

    if (forgeCredentials !== undefined && forgeOrigin !== undefined) {

      process.onRequest("git/push", async (rawParams: unknown) => {

        const params = record(rawParams);

        const refspec = firstString(params, ["refspec"]);

        const remote = firstString(params, ["remote"]) ?? "origin";

        if (refspec === undefined) {

          return { ok: false, error: "delegated push requires a refspec" };

        }

        try {

          await Effect.runPromise(

            pushDelegated({

              directory: request.cwd,

              remote,

              refspec,

              repository: forgeCredentials.repository,

              branch: forgeCredentials.branch,

              credential: forgeCredentials.token,

              origin: forgeOrigin,

            }),

          );

          return { ok: true };

        } catch (cause) {

          const message = cause instanceof Error ? cause.message : String(cause);

          return { ok: false, error: scrub(message) };

        }

      });

    }

    const initialized = record(

      await process.request("initialize", {

        protocolVersion: 1,

import { Effect, Layer, Option } from "effect";

import { Effect, Layer, Option, Redacted } from "effect";

import * as Context from "effect/Context";

import type { ForgeCredentials } from "./delegation-push.js";

import {

  ComputerChannel,

  type ComputerAgentResponder,

        outcome: string,

        detail: string,

      ) => journal(journalService, requestId, request, decision, outcome, detail);

      const recordValue = (value: unknown): Record<string, unknown> =>

        typeof value === "object" && value !== null && !Array.isArray(value)

          ? { ...(value as Record<string, unknown>) }

          : {};

      const asString = (value: unknown): string | undefined =>

        typeof value === "string" && value !== "" ? value : undefined;

      const extractForgeCredentials = (

        payload: Record<string, unknown>,

      ): ForgeCredentials | undefined => {

        const raw = payload.assignment_credential ?? payload.forge_credentials;

        let token: string | undefined;

        let repository: string | undefined;

        let branch: string | undefined;

        if (typeof raw === "string") {

          token = raw;

          repository = asString(payload.assignment_repository);

          branch = asString(payload.assignment_branch);

        } else if (typeof raw === "object" && raw !== null) {

          const cred = recordValue(raw);

          const candidate =

            cred.token ?? cred.value ?? cred.password ?? cred.access_token;

          token = asString(candidate);

          repository = asString(cred.repository ?? payload.assignment_repository);

          branch = asString(cred.branch ?? payload.assignment_branch);

        }

        if (token === undefined || repository === undefined || branch === undefined)

          return undefined;

        return { token: Redacted.make(token), repository, branch };

      };

      const handlers: ComputerChannelHandlers = {

        onProbe: async (requestId) => {

          const request = { argv: ["<probe>"], cwd: config.roots[0] ?? "" };

          const cwd = typeof payload.cwd === "string" ? resolve(payload.cwd) : "";

          const request = { argv: ["<agent>", agentId.slice(0, 64)], cwd };

          append(requestId, request, "received", "pending", "ACP delegation received");

          if (

          const forgeCredentials = extractForgeCredentials(payload);

          if (forgeCredentials !== undefined) {

            append(

              requestId,

              request,

              "credentials_delivered",

              "configured",

              "scoped forge credentials configured for delegated push",

            );

          } else if (

            Object.hasOwn(payload, "assignment_credential") ||

            Object.hasOwn(payload, "forge_credentials")

          ) {

              requestId,

              request,

              "credentials_delivered",

              "not_used",

              "scoped forge credentials delivered; not used by this ACP delegation",

              "incomplete",

              "scoped forge credentials delivered but missing repository or branch",

            );

          }

          if (Option.isNone(agentProcess)) {

            roots: config.roots,

            curatedExecute: config.curatedExecute ?? [],

            env: environment,

            ...(forgeCredentials !== undefined

              ? { forgeCredentials, forgeOrigin: origin }

              : {}),

            timeoutMs: numberField(

              payload,

              ["timeout_ms", "timeout"],

import { Effect, Redacted } from "effect";

import { execFile, spawn } from "node:child_process";

import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";

import { join } from "node:path";

import { tmpdir } from "node:os";

import { GitExecutionError, InputError } from "./errors.js";

import { repositoryFromRemoteUrl, validateRemoteName } from "./git-runner.js";

import { scrubbedEnvironment } from "./computer-executor.js";

export interface ForgeCredentials {

  readonly token: Redacted.Redacted<string>;

  readonly repository: string;

  readonly branch: string;

}

export interface DelegatedPushInput {

  readonly directory: string;

  readonly remote: string;

  readonly refspec: string;

  readonly repository: string;

  readonly branch: string;

  readonly credential: Redacted.Redacted<string>;

  readonly origin: string;

}

export const redactSecret = (value: string): string =>

  value

    .replaceAll(

      /(?:oa_(?:pat|agent|assignment)_[A-Za-z0-9._-]+|smct_[A-Za-z0-9._-]+)/gu,

      "[REDACTED]",

    )

    .replaceAll(/Bearer\s+\S+/giu, "Bearer [REDACTED]")

    .replaceAll(

      /(?:api[-_]?key|token|secret|password|authorization)\s*[=:]\s*\S+/giu,

      "[REDACTED]",

    );

const canonicalBranch = (branch: string): string =>

  branch.startsWith("refs/heads/") ? branch : `refs/heads/${branch}`;

const toCanonical = (value: string, branch: string): string | undefined => {

  const target = canonicalBranch(branch);

  if (value === branch || value === target) return target;

  return undefined;

};

export const validateRefspec = Effect.fn("DelegationPush.validateRefspec")(

  function* (refspec: string, branch: string) {

    if (refspec === "") {

      return yield* new InputError({ message: "The refspec is empty." });

    }

    if (/[\s,]/u.test(refspec)) {

      return yield* new InputError({

        message: `Multi-ref push is not allowed: ${redactSecret(refspec)}`,

      });

    }

    if (refspec.startsWith("+") || refspec.startsWith("-")) {

      return yield* new InputError({

        message: `Force or option refspecs are not allowed: ${redactSecret(refspec)}`,

      });

    }

    const target = canonicalBranch(branch);

    const colon = refspec.indexOf(":");

    if (colon >= 0) {

      const src = refspec.slice(0, colon);

      const dst = refspec.slice(colon + 1);

      if (dst === "") {

        return yield* new InputError({

          message: `A refspec with an empty destination is not allowed: ${redactSecret(refspec)}`,

        });

      }

      const srcCanonical = toCanonical(src, branch);

      const dstCanonical = toCanonical(dst, branch);

      if (srcCanonical === undefined || dstCanonical === undefined || srcCanonical !== dstCanonical) {

        return yield* new InputError({

          message: `Refspec ${redactSecret(refspec)} is not the assigned branch ${target}.`,

        });

      }

      return;

    }

    if (toCanonical(refspec, branch) === undefined) {

      return yield* new InputError({

        message: `Refspec ${redactSecret(refspec)} is not the assigned branch ${target}.`,

      });

    }

  },

);

const getRemoteUrl = (

  directory: string,

  remote: string,

): Effect.Effect<string, GitExecutionError> =>

  Effect.tryPromise({

    try: () =>

      new Promise<string>((resolve, reject) => {

        execFile(

          "git",

          ["remote", "get-url", "--", remote],

          { cwd: directory },

          (error, stdout, stderr) => {

            if (error) {

              reject(

                new Error(

                  `git remote get-url failed: ${redactSecret(stderr.trim() || String(error))}`,

                ),

              );

              return;

            }

            resolve(stdout.trim());

          },

        );

      }),

    catch: (cause) =>

      new GitExecutionError({

        operation: "git remote get-url",

        message: redactSecret(

          cause instanceof Error ? cause.message : String(cause),

        ),

      }),

  });

const runGit = (

  operation: string,

  args: ReadonlyArray<string>,

  directory: string,

  env: Record<string, string>,

): Effect.Effect<{ readonly exitCode: number; readonly stderr: string }, GitExecutionError> =>

  Effect.tryPromise({

    try: () =>

      new Promise<{ exitCode: number; stderr: string }>((resolve, reject) => {

        let stderr = "";

        const child = spawn("git", [...args], {

          cwd: directory,

          env,

          shell: false,

          stdio: ["ignore", "pipe", "pipe"],

        });

        child.on("error", (cause) =>

          reject(

            new Error(

              `git ${operation} could not start: ${redactSecret(cause.message)}`,

            ),

          ),

        );

        child.stderr.on("data", (chunk: Buffer) => {

          if (stderr.length < 16_384) {

            stderr += chunk.toString("utf8");

          }

        });

        child.on("close", (code) =>

          resolve({

            exitCode: code ?? 1,

            stderr: redactSecret(stderr.trim()),

          }),

        );

      }),

    catch: (cause) =>

      new GitExecutionError({

        operation: `git ${operation}`,

        message: redactSecret(

          cause instanceof Error ? cause.message : String(cause),

        ),

      }),

  });

const buildCredentialHelper = (

  directory: string,

  token: string,

  expectedHost: string,

  expectedPath: string,

): string => {

  const tokenPath = join(directory, "token");

  const helperPath = join(directory, "helper");

  writeFileSync(tokenPath, `${token}\n`, { mode: 0o600 });

  chmodSync(tokenPath, 0o600);

  const script = `#!/bin/sh

if [ "$1" != "get" ]; then

  exit 0

fi

host=""

path=""

while IFS= read -r line; do

  [ -z "$line" ] && break

  case "$line" in

    host=*) host="\${line#host=}" ;;

    path=*) path="\${line#path=}" ;;

  esac

done

if [ "$host" != ${JSON.stringify(expectedHost)} ] || [ "$path" != ${JSON.stringify(expectedPath)} ]; then

  exit 0

fi

PASSWORD=$(tr -d '\\n' < ${JSON.stringify(tokenPath)})

printf 'username=openagents\\npassword=%s\\n\\n' "$PASSWORD"

`;

  writeFileSync(helperPath, script, { mode: 0o700 });

  chmodSync(helperPath, 0o700);

  return helperPath;

};

export const pushDelegated = (

  input: DelegatedPushInput,

): Effect.Effect<void, GitExecutionError | InputError> =>

  Effect.tryPromise({

    try: async () => {

      await Effect.runPromise(validateRefspec(input.refspec, input.branch));

      const remote = await Effect.runPromise(validateRemoteName(input.remote));

      const rawUrl = await Effect.runPromise(getRemoteUrl(input.directory, remote));

      const actualRepository = await Effect.runPromise(

        repositoryFromRemoteUrl(input.origin, rawUrl),

      );

      if (actualRepository !== input.repository) {

        throw new InputError({

          message: `The remote repository is ${actualRepository}, not the assigned ${input.repository}.`,

        });

      }

      const token = Redacted.value(input.credential);

      const tempDir = mkdtempSync(join(tmpdir(), "oa-delegation-push-"));

      chmodSync(tempDir, 0o700);

      try {

        const remoteUrl = new URL(rawUrl);

        const helperPath = buildCredentialHelper(

          tempDir,

          token,

          remoteUrl.host,

          remoteUrl.pathname.replace(/^\//u, ""),

        );

        const helperConfig = `!${helperPath}`;

        const gitArgs = [

          "-c",

          "credential.helper=",

          "-c",

          `credential.${remoteUrl.origin}.helper=${helperConfig}`,

          "push",

          "--",

          remote,

          input.refspec,

        ];

        const result = await Effect.runPromise(

          runGit("push", gitArgs, input.directory, {

            ...scrubbedEnvironment(process.env),

            GIT_TERMINAL_PROMPT: "0",

          }),

        );

        if (result.exitCode !== 0) {

          throw new GitExecutionError({

            operation: "delegated git push",

            exitCode: result.exitCode,

            message: `git push failed: ${result.stderr}`,

          });

        }

      } finally {

        try {

          rmSync(tempDir, { recursive: true, force: true });

        } catch {

          // Cleanup is best-effort; the token file is already as protected as the

          // temporary directory allows.

        }

      }

    },

    catch: (cause) => {

      if (cause instanceof InputError) return cause;

      if (cause instanceof GitExecutionError) return cause;

      return new GitExecutionError({

        operation: "delegated git push",

        message: redactSecret(String(cause)),

      });

    },

  });

        prompt: "delegate",

        cwd: "/workspace",

        assignment_credential: "forge-secret",

        assignment_repository: "owner/repo",

        assignment_branch: "feature-1",

        env: { FORGE_TOKEN: "forge-secret" },

      },

      {

    expect(terminal).toContainEqual(

      expect.objectContaining({

        decision: "credentials_delivered",

        outcome: "not_used",

        detail: "scoped forge credentials delivered; not used by this ACP delegation",

        outcome: "configured",

        detail: "scoped forge credentials configured for delegated push",

      }),

    );

  });

import { Effect, Redacted } from "effect";

import {

  chmodSync,

  mkdtempSync,

  readFileSync,

  readdirSync,

  rmSync,

  writeFileSync,

} from "node:fs";

import { join } from "node:path";

import { tmpdir } from "node:os";

import { afterEach, beforeEach, describe, expect, it } from "vitest";

import {

  pushDelegated,

  redactSecret,

  validateRefspec,

} from "../src/delegation-push.js";

const CANARY = "oa_assignment_canary_12345";

const makeFakeGit = (opts: {

  readonly fail?: boolean;

  readonly stderr?: string;

}): { readonly dir: string; readonly log: string; readonly originalPath: string } => {

  const dir = mkdtempSync(join(tmpdir(), "oa-fake-git-"));

  const log = join(dir, "git.log");

  const script = `#!/bin/sh

CANARY="${CANARY}"

for arg in "$@"; do

  if [ "$arg" = "get-url" ]; then

    echo "https://openagents.com/owner/repo.git"

    exit 0

  fi

  if [ "$arg" = "push" ]; then

    for a in "$@"; do

      printf "%s\\n" "$a" >> ${JSON.stringify(log)}

    done

    printf "%s\\n" "---" >> ${JSON.stringify(log)}

    if [ -n "${opts.stderr ?? ""}" ]; then

      printf "%s\\n" "${opts.stderr ?? ""}" >&2

    fi

    exit ${opts.fail ? 1 : 0}

  fi

done

exit 1

`;

  writeFileSync(join(dir, "git"), script, { mode: 0o755 });

  chmodSync(join(dir, "git"), 0o755);

  return { dir, log, originalPath: process.env.PATH ?? "" };

};

const setPath = (dir: string): void => {

  process.env.PATH = `${dir}:${process.env.PATH ?? ""}`;

};

const restorePath = (original: string): void => {

  process.env.PATH = original;

};

describe("delegated push refspec validation", () => {

  it("allows the assigned branch by short name, full ref, or matching src:dst", async () => {

    await expect(

      Effect.runPromise(validateRefspec("feature-1", "feature-1")),

    ).resolves.toBeUndefined();

    await expect(

      Effect.runPromise(validateRefspec("refs/heads/feature-1", "feature-1")),

    ).resolves.toBeUndefined();

    await expect(

      Effect.runPromise(

        validateRefspec("refs/heads/feature-1:refs/heads/feature-1", "feature-1"),

      ),

    ).resolves.toBeUndefined();

    await expect(

      Effect.runPromise(validateRefspec("feature-1:feature-1", "feature-1")),

    ).resolves.toBeUndefined();

  });

  it("refuses an unauthorized branch, a mismatched src:dst, and invalid forms", async () => {

    await expect(

      Effect.runPromise(validateRefspec("main", "feature-1")),

    ).rejects.toThrow(/not the assigned branch/);

    await expect(

      Effect.runPromise(validateRefspec("refs/heads/main", "feature-1")),

    ).rejects.toThrow(/not the assigned branch/);

    await expect(

      Effect.runPromise(

        validateRefspec("refs/heads/feature-1:refs/heads/main", "feature-1"),

      ),

    ).rejects.toThrow(/not the assigned branch/);

    await expect(

      Effect.runPromise(validateRefspec("refs/tags/v1", "feature-1")),

    ).rejects.toThrow(/not the assigned branch/);

    await expect(

      Effect.runPromise(validateRefspec("", "feature-1")),

    ).rejects.toThrow(/empty/);

    await expect(

      Effect.runPromise(validateRefspec("+feature-1", "feature-1")),

    ).rejects.toThrow(/Force or option/);

    await expect(

      Effect.runPromise(validateRefspec("feature-1:", "feature-1")),

    ).rejects.toThrow(/empty destination/);

  });

  it("refuses a multi-ref push", async () => {

    await expect(

      Effect.runPromise(validateRefspec("feature-1 main", "feature-1")),

    ).rejects.toThrow(/Multi-ref/);

    await expect(

      Effect.runPromise(validateRefspec("feature-1,main", "feature-1")),

    ).rejects.toThrow(/Multi-ref/);

  });

});

describe("delegated push credential redaction", () => {

  it("redacts known credential patterns", () => {

    expect(redactSecret("token oa_assignment_canary_12345 here")).not.toContain(

      CANARY,

    );

    expect(redactSecret("token oa_assignment_canary_12345 here")).toContain(

      "[REDACTED]",

    );

    const auth = redactSecret("Authorization: Bearer abc.def");

    expect(auth).not.toContain("abc.def");

    expect(auth).toContain("[REDACTED]");

    expect(redactSecret("api-key=secret")).toBe("[REDACTED]");

    expect(redactSecret("password=s3cr3t")).toBe("[REDACTED]");

  });

});

describe("delegated push lifecycle", () => {

  const pushDir = () => mkdtempSync(join(tmpdir(), "oa-delegation-test-root-"));

  const cleanupTemp = (): void => {

    for (const name of readdirSync(tmpdir())) {

      if (

        name.startsWith("oa-delegation-push-") ||

        name.startsWith("oa-delegation-test-root-")

      ) {

        try {

          rmSync(join(tmpdir(), name), { recursive: true, force: true });

        } catch {

          // ignore

        }

      }

    }

  };

  let fake: ReturnType<typeof makeFakeGit> | undefined;

  beforeEach(() => {

    cleanupTemp();

  });

  afterEach(() => {

    if (fake !== undefined) {

      restorePath(fake.originalPath);

      rmSync(fake.dir, { recursive: true, force: true });

      fake = undefined;

    }

    cleanupTemp();

  });

  it("pushes the assigned branch and cleans up the credential temp directory", async () => {

    fake = makeFakeGit({ fail: false });

    setPath(fake.dir);

    const directory = pushDir();

    await expect(

      Effect.runPromise(

        pushDelegated({

          directory,

          remote: "origin",

          refspec: "feature-1",

          repository: "owner/repo",

          branch: "feature-1",

          credential: Redacted.make(CANARY),

          origin: "https://openagents.com",

        }),

      ),

    ).resolves.toBeUndefined();

    const log = fake.log;

    const logged = readLog(log);

    expect(logged.join("\n")).not.toContain(CANARY);

    expect(logged).toContain("origin");

    expect(logged).toContain("feature-1");

    expect(logged).toContain("push");

    expect(logged.some((line) => line.startsWith("credential."))).toBe(true);

    expect(readdirSync(tmpdir()).some((n) => n.startsWith("oa-delegation-push-"))).toBe(false);

  });

  it("fails distinguishably for a ref mismatch before any git push", async () => {

    fake = makeFakeGit({ fail: false });

    setPath(fake.dir);

    const directory = pushDir();

    await expect(

      Effect.runPromise(

        pushDelegated({

          directory,

          remote: "origin",

          refspec: "main",

          repository: "owner/repo",

          branch: "feature-1",

          credential: Redacted.make(CANARY),

          origin: "https://openagents.com",

        }),

      ),

    ).rejects.toThrow(/not the assigned branch/);

  });

  it("fails distinguishably when the remote repository does not match the assignment", async () => {

    fake = makeFakeGit({ fail: false });

    setPath(fake.dir);

    const directory = pushDir();

    await expect(

      Effect.runPromise(

        pushDelegated({

          directory,

          remote: "origin",

          refspec: "feature-1",

          repository: "wrong/repo",

          branch: "feature-1",

          credential: Redacted.make(CANARY),

          origin: "https://openagents.com",

        }),

      ),

    ).rejects.toThrow(/not the assigned/);

  });

  it("fails with a redacted message and cleans up after a git push failure", async () => {

    fake = makeFakeGit({

      fail: true,

      stderr: `error: invalid token ${CANARY}`,

    });

    setPath(fake.dir);

    const directory = pushDir();

    let error: unknown;

    try {

      await Effect.runPromise(

        pushDelegated({

          directory,

          remote: "origin",

          refspec: "feature-1",

          repository: "owner/repo",

          branch: "feature-1",

          credential: Redacted.make(CANARY),

          origin: "https://openagents.com",

        }),

      );

    } catch (cause) {

      error = cause;

    }

    expect(error).toBeInstanceOf(Error);

    const message = error instanceof Error ? error.message : String(error);

    expect(message).toContain("git push failed");

    expect(message).not.toContain(CANARY);

    expect(message).toContain("[REDACTED]");

    expect(

      readdirSync(tmpdir()).some((n) => n.startsWith("oa-delegation-push-")),

    ).toBe(false);

  });

});

const readLog = (path: string): ReadonlyArray<string> => {

  try {

    return readFileSync(path, "utf8")

      .split("\n")

      .filter((line) => line !== "");

  } catch {

    return [];

  }

};