Add low-trust review containment (#7530)

## Thinking Path

> - Paperclip is a control plane for AI-agent companies, so execution
policy and trust boundaries are part of the product's safety contract.
> - Low-trust review work needs narrower authority than normal
same-company agents because hostile PRs, comments, attachments, and
generated output can carry prompt-injection payloads.
> - The current V1 shape gives trusted workers broad company context,
which is useful for normal execution but too permissive for a reviewer
assigned to hostile content.
> - This branch adds a `low_trust_review` preset, source-trust tagging,
route-level containment, and quarantine handling so low-trust output
does not automatically flow into higher-trust wake context.
> - The branch has been rebased onto current `origin/master`, and the
low-trust migration was renumbered to `0097_low_trust_source_trust.sql`
to avoid collisions with existing `0091` through `0096` migrations.
> - Greptile feedback was addressed by tightening low-trust detection,
preserving project-level trust policy checks, fixing issue-kind
promotion lookup, removing duplicate post-lease isolation assertion,
documenting fail-closed source-trust behavior, bounding ancestry checks,
enforcing runtime issue context for CEOs, awaiting accepted-plan monitor
authorization, and making low-trust issue source-trust tagging atomic.
> - The benefit is a first production slice of deny-by-default review
containment with regression coverage for the main control-plane pivot
surfaces.

Fixes #7531.

## What Changed

- Added shared trust-policy types and validators, plus
database/source-trust fields for issues, comments, documents, and work
products.
- Implemented server enforcement for low-trust issue scope, agent
self-view redaction, secret/plugin/runtime denial paths, promotion
checks, and quarantined continuation/wake context.
- Added focused low-trust regression tests for resolver behavior, source
trust, route authorization, heartbeat preflight ordering, runtime
containment, and quarantine redaction.
- Added board UI affordances for selecting/reviewing the low-trust
preset and surfacing source-trust badges in relevant issue views.
- Added `doc/LOW-TRUST-PRESETS.md`, updated
`doc/SPEC-implementation.md`, and committed the low-trust review
contract plan under `doc/plans/`.
- Rebasing note: the original `0097_low_trust_source_trust.sql`
migration was renamed to `0097_low_trust_source_trust.sql`; the SQL uses
`ADD COLUMN IF NOT EXISTS` so users who already applied the old-numbered
migration are not broken by the renumbered migration.

## Verification

- Rebased branch onto current `origin/master` and force-pushed with
lease to `origin/PAP-10211-low-trust-agent` at head `2719f31e3`.
- Confirmed the PR diff does not include `pnpm-lock.yaml` or
`.github/workflows` changes.
- Resolved upstream UI/comment conflicts by preserving deleted-comment
tombstone behavior and low-trust source-trust badges/metadata.
- Renumbered the low-trust source-trust migration to
`0097_low_trust_source_trust.sql`; the SQL uses `ADD COLUMN IF NOT
EXISTS` so users who already applied an old-numbered copy are not
broken.
- `pnpm exec vitest run ui/src/lib/issue-chat-messages.test.ts
server/src/__tests__/heartbeat-workspace-session.test.ts`
- `pnpm exec vitest run server/src/__tests__/source-trust.test.ts
server/src/__tests__/workspace-runtime-service-authz.test.ts
ui/src/lib/trust-policy-ui.test.ts
ui/src/components/TrustPresetSection.test.tsx`
- `pnpm run typecheck:build-gaps`
- `git diff --check`
- GitHub checks pass on head `2719f31e3`: build, typecheck/release
registry, general tests, serialized server suites, e2e, canary, verify,
policy/review, Socket, and Snyk.
- Greptile Review passes with Confidence Score 5/5 and zero unresolved
Greptile review threads.
- No design screenshots/images were added because the task explicitly
says not to add them unless they are specifically part of the work.

## Risks

- Medium risk: this touches shared trust-policy contracts, server
authorization paths, heartbeat context generation, migration metadata,
and UI preset controls.
- Low-trust containment is intentionally deny-by-default; legitimate
future review workflows may need explicit allowlisted exceptions.
- Plugin/runtime/security surfaces are broad, so regression tests cover
the current known routes but future integrations must route through the
same containment layer.
- The PR is ready for review; GitHub checks are green and Greptile is
5/5.

> For core feature work, check [`ROADMAP.md`](ROADMAP.md) first and
discuss it in `#dev` before opening the PR. Feature PRs that overlap
with planned core work may need to be redirected — check the roadmap
first. See `CONTRIBUTING.md`.

## Model Used

- OpenAI Codex, GPT-5 coding agent, tool-enabled shell and GitHub CLI
workflow.

## Checklist

- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used (with version and capability
details)
- [x] I have checked ROADMAP.md and confirmed this PR does not duplicate
planned core work
- [x] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [x] UI changes are covered by focused tests; no screenshots were added
per task instruction not to add design images unless specifically
required
- [x] I have updated relevant documentation to reflect my changes
- [x] I have considered and documented any risks above
- [x] I will address all Greptile and reviewer comments before
requesting merge

---------

Co-authored-by: Paperclip <noreply@paperclip.ing>
This commit is contained in:
Dotta
2026-06-05 11:48:02 -10:00
committed by GitHub
parent b2a33d0184
commit dbebf30c89
87 changed files with 6522 additions and 121 deletions
@@ -6,9 +6,11 @@ import {
companyMemberships,
createDb,
instanceUserRoles,
issues,
principalPermissionGrants,
projects,
} from "@paperclipai/db";
import { LOW_TRUST_REVIEW_PRESET } from "@paperclipai/shared";
import {
getEmbeddedPostgresTestSupport,
startEmbeddedPostgresTestDatabase,
@@ -61,6 +63,33 @@ async function createProject(db: ReturnType<typeof createDb>, companyId: string,
.then((rows) => rows[0]!);
}
async function createIssue(
db: ReturnType<typeof createDb>,
companyId: string,
input: {
id?: string;
title?: string;
projectId?: string | null;
parentId?: string | null;
assigneeAgentId?: string | null;
} = {},
) {
return db
.insert(issues)
.values({
id: input.id ?? randomUUID(),
companyId,
title: input.title ?? `Issue ${randomUUID()}`,
status: "todo",
priority: "medium",
projectId: input.projectId ?? null,
parentId: input.parentId ?? null,
assigneeAgentId: input.assigneeAgentId ?? null,
})
.returning()
.then((rows) => rows[0]!);
}
async function grantAgentPermission(
db: ReturnType<typeof createDb>,
companyId: string,
@@ -98,6 +127,7 @@ describeEmbeddedPostgres("authorization service", () => {
await db.delete(principalPermissionGrants);
await db.delete(companyMemberships);
await db.delete(instanceUserRoles);
await db.delete(issues);
await db.delete(agents);
await db.delete(projects);
await db.delete(companies);
@@ -218,6 +248,141 @@ describeEmbeddedPostgres("authorization service", () => {
expect(decision.explanation).toContain("simple mode");
});
it("limits low-trust issue reads to the configured project and root issue boundary", async () => {
const company = await createCompany(db, "LowTrustIssueReads");
const project = await createProject(db, company.id, "Allowed");
const otherProject = await createProject(db, company.id, "Denied");
const rootIssueId = randomUUID();
const actorAgent = await createAgent(db, company.id, {
permissions: {
trustPreset: LOW_TRUST_REVIEW_PRESET,
authorizationPolicy: {
trustBoundary: {
mode: LOW_TRUST_REVIEW_PRESET,
projectIds: [project.id],
rootIssueId,
},
},
},
});
const rootIssue = await createIssue(db, company.id, {
id: rootIssueId,
projectId: project.id,
assigneeAgentId: actorAgent.id,
});
const childIssue = await createIssue(db, company.id, {
projectId: project.id,
parentId: rootIssue.id,
});
const unrelatedIssue = await createIssue(db, company.id, {
projectId: otherProject.id,
});
const authorization = authorizationService(db);
const actor = { type: "agent" as const, agentId: actorAgent.id, companyId: company.id, source: "agent_key" as const };
const rootDecision = await authorization.decide({
actor,
action: "issue:read",
resource: {
type: "issue",
companyId: company.id,
issueId: rootIssue.id,
projectId: rootIssue.projectId,
parentIssueId: rootIssue.parentId,
assigneeAgentId: rootIssue.assigneeAgentId,
status: rootIssue.status,
},
});
const childDecision = await authorization.decide({
actor,
action: "issue:read",
resource: {
type: "issue",
companyId: company.id,
issueId: childIssue.id,
projectId: childIssue.projectId,
parentIssueId: childIssue.parentId,
status: childIssue.status,
},
});
const unrelatedDecision = await authorization.decide({
actor,
action: "issue:read",
resource: {
type: "issue",
companyId: company.id,
issueId: unrelatedIssue.id,
projectId: unrelatedIssue.projectId,
parentIssueId: unrelatedIssue.parentId,
status: unrelatedIssue.status,
},
});
expect(rootDecision).toMatchObject({ allowed: true, reason: "allow_low_trust_boundary" });
expect(childDecision).toMatchObject({ allowed: true, reason: "allow_low_trust_boundary" });
expect(unrelatedDecision).toMatchObject({ allowed: false, reason: "deny_low_trust_boundary" });
});
it("blocks low-trust project, agent, company-wide, and outside-boundary assignment access", async () => {
const company = await createCompany(db, "LowTrustOtherResources");
const project = await createProject(db, company.id, "Allowed");
const otherProject = await createProject(db, company.id, "Denied");
const collaborator = await createAgent(db, company.id);
const higherTrustAgent = await createAgent(db, company.id, { role: "cto" });
const actorAgent = await createAgent(db, company.id, {
permissions: {
trustPreset: LOW_TRUST_REVIEW_PRESET,
authorizationPolicy: {
trustBoundary: {
mode: LOW_TRUST_REVIEW_PRESET,
projectIds: [project.id],
allowedAgentIds: [collaborator.id],
},
},
},
});
const authorization = authorizationService(db);
const actor = { type: "agent" as const, agentId: actorAgent.id, companyId: company.id, source: "agent_key" as const };
await expect(authorization.decide({
actor,
action: "project:read",
resource: { type: "project", companyId: company.id, projectId: project.id },
})).resolves.toMatchObject({ allowed: true, reason: "allow_low_trust_boundary" });
await expect(authorization.decide({
actor,
action: "project:read",
resource: { type: "project", companyId: company.id, projectId: otherProject.id },
})).resolves.toMatchObject({ allowed: false, reason: "deny_low_trust_boundary" });
await expect(authorization.decide({
actor,
action: "agent:read",
resource: { type: "agent", companyId: company.id, agentId: collaborator.id },
})).resolves.toMatchObject({ allowed: true, reason: "allow_low_trust_boundary" });
await expect(authorization.decide({
actor,
action: "agent:read",
resource: { type: "agent", companyId: company.id, agentId: higherTrustAgent.id },
})).resolves.toMatchObject({ allowed: false, reason: "deny_low_trust_boundary" });
await expect(authorization.decide({
actor,
action: "company_scope:read",
resource: { type: "company", companyId: company.id },
})).resolves.toMatchObject({ allowed: false, reason: "deny_low_trust_boundary" });
await expect(authorization.decide({
actor,
action: "tasks:assign",
resource: {
type: "issue",
companyId: company.id,
projectId: project.id,
assigneeAgentId: higherTrustAgent.id,
},
scope: { projectId: project.id, assigneeAgentId: higherTrustAgent.id },
})).resolves.toMatchObject({ allowed: false, reason: "deny_low_trust_boundary" });
});
it("denies simple-mode assignment when the target agent requires protected-assignment approval", async () => {
const company = await createCompany(db, "ProtectedAssignment");
const actorAgent = await createAgent(db, company.id, { role: "engineer" });