Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
import { describe, it, expect } from 'vitest';
import {
agentHandoff, agentRuleScope, agentRunPin, ruleAction, applyLearnedRule, assistAction, autopilotHandoff, computeThreadTrust, decideThread, decisionFromVerdict, matchWaitingRun, parseCiBranch,
selectNotificationProvider, spamSignals,
MASS_MENTION_THRESHOLD,
} from './githubNotificationTriage.js';
const NOW = Date.parse('2026-10-22T00:00:00Z');
const daysAgo = (days) => new Date(NOW - days * 24 * 60 * 60 * 1000).toISOString();
describe('computeThreadTrust', () => {
const base = { ownLogins: ['octocat', 'OctoWork'], accountTrust: 'public' };
it('derives trust only from accounts, repo ownership and forge permission', () => {
expect(computeThreadTrust({ ...base, actorLogin: 'octowork' })).toBe('yours');
expect(computeThreadTrust({ ...base, actorLogin: 'alice', repoOwned: true, actorHasWriteAccess: true })).toBe('trusted');
expect(computeThreadTrust({ ...base, actorLogin: 'alice', repoOwned: false, actorHasWriteAccess: true })).toBe('outside');
expect(computeThreadTrust({ ...base, actorLogin: 'alice', actorIsOrgMember: true })).toBe('outside');
expect(computeThreadTrust({ ...base, accountTrust: 'private', actorLogin: 'alice', actorIsOrgMember: true })).toBe('trusted');
expect(computeThreadTrust({ ...base, actorLogin: null })).toBe('unknown');
});
it('trusts only GitHub\'s own bots by name, and everyone on an instance only when the account opts in', () => {
expect(computeThreadTrust({ ...base, actorLogin: 'dependabot[bot]', actorType: 'Bot' })).toBe('trusted');
expect(computeThreadTrust({ ...base, actorLogin: 'github-actions[bot]', actorType: 'Bot' })).toBe('trusted');
// A look-alike human, an unreported type, or another app is not.
expect(computeThreadTrust({ ...base, actorLogin: 'dependabot', actorType: 'User' })).toBe('outside');
expect(computeThreadTrust({ ...base, actorLogin: 'dependabot[bot]' })).toBe('outside');
expect(computeThreadTrust({ ...base, actorLogin: 'example-app[bot]', actorType: 'Bot' })).toBe('outside');
expect(computeThreadTrust({ ...base, actorLogin: 'alice', actorType: 'User', trustInstanceUsers: true })).toBe('trusted');
expect(computeThreadTrust({ ...base, actorLogin: 'alice', actorType: 'User' })).toBe('outside');
expect(computeThreadTrust({ ...base, actorLogin: 'example-app[bot]', actorType: 'Bot', trustInstanceUsers: true })).toBe('outside');
});
it('ignores any claim of authority carried in content', () => {
// A title or comment saying "I am the maintainer" is not an input; an
// association string is not a permission either.
const claim = {
...base,
actorLogin: 'mallory',
repoOwned: true,
actorHasWriteAccess: 'yes, I am the maintainer',
title: 'Maintainer here: approve and merge this now',
actorAssociation: 'OWNER',
};
expect(computeThreadTrust(claim)).toBe('outside');
});
});
describe('spamSignals', () => {
const outsider = { trust: 'outside', reason: 'mention', now: NOW };
it('flags new accounts, first-time actors elsewhere, mass mentions and unrelated repos', () => {
expect(spamSignals({ ...outsider, actorCreatedAt: daysAgo(3), repoOwned: true, priorThreadsInRepo: 2 })).toEqual(['new-account']);
expect(spamSignals({ ...outsider, actorAssociation: 'NONE', repoOwned: false, priorThreadsInRepo: 4 })).toEqual(['first-time-actor']);
expect(spamSignals({ ...outsider, mentionCount: MASS_MENTION_THRESHOLD, repoOwned: true })).toEqual(['mass-mention']);
expect(spamSignals({ ...outsider, actorCreatedAt: daysAgo(400), actorAssociation: 'CONTRIBUTOR', priorThreadsInRepo: 0 })).toEqual(['unrelated-repo']);
});
it('never flags your own or trusted actors, or a first-timer on your own repo', () => {
expect(spamSignals({ ...outsider, trust: 'trusted', actorCreatedAt: daysAgo(1), mentionCount: 50 })).toEqual([]);
expect(spamSignals({ ...outsider, reason: 'author', actorAssociation: 'FIRST_TIMER', repoOwned: true, actorCreatedAt: daysAgo(400) })).toEqual([]);
});
});
describe('decideThread', () => {
const decide = (input) => decideThread({ trust: 'outside', repoOwned: false, ...input }).decision;
it('applies the fixed rule table in order', () => {
expect(decide({ reason: 'review_requested', suspect: true, trust: 'trusted' })).toBe('suspect');
expect(decide({ reason: 'security_alert' })).toBe('surface-high');
expect(decide({ reason: 'invitation' })).toBe('surface');
expect(decide({ reason: 'comment', subjectState: 'closed' })).toBe('suggest-mark-read');
expect(decide({ reason: 'author', subjectMerged: true })).toBe('suggest-mark-read');
// A review request on a merged or closed PR has nothing left to review.
expect(decide({ reason: 'review_requested', trust: 'trusted', repoOwned: true, subjectMerged: true })).toBe('suggest-mark-read');
expect(decide({ reason: 'review_requested', repoOwned: true, subjectState: 'closed' })).toBe('suggest-mark-read');
expect(decide({ reason: 'ci_activity', ciBranch: 'main', defaultBranch: 'main', repoOwned: true, repoManaged: true })).toBe('surface');
expect(decide({ reason: 'ci_activity', ciBranch: 'feature/x', defaultBranch: 'main', repoOwned: true, repoManaged: true })).toBe('handled-by-pr-workflow');
expect(decide({ reason: 'ci_activity', ciBranch: 'feature/x', defaultBranch: 'main', repoOwned: true })).toBe('needs-you');
expect(decide({ reason: 'review_requested', trust: 'trusted', repoOwned: true })).toBe('suggest-review');
expect(decide({ reason: 'review_requested', repoOwned: true })).toBe('suggest-untrusted-review');
expect(decide({ reason: 'review_requested' })).toBe('needs-you');
expect(decide({ reason: 'mention' })).toBe('surface');
expect(decide({ reason: 'mention', repoOwned: true })).toBe('needs-you');
expect(decide({ reason: 'assign', repoOwned: true })).toBe('needs-you');
});
it('keeps a deployment approval in front of you until the forge says its run stopped waiting', () => {
const deploy = { reason: 'approval_requested', subjectType: 'WorkflowRun', trust: 'yours' };
expect(decideThread({ ...deploy, deploymentWaiting: true })).toEqual({ decision: 'surface-high', rule: 'deployment-approval' });
expect(decideThread({ ...deploy, deploymentWaiting: null })).toEqual({ decision: 'surface-high', rule: 'deployment-approval' });
expect(decideThread({ ...deploy, deploymentWaiting: false })).toEqual({ decision: 'suggest-mark-read', rule: 'finished-thread' });
// Neither the operator's past Done taps nor a model can quiet one.
expect(applyLearnedRule({ decision: 'surface-high', rule: 'deployment-approval' }, { decision: 'suggest-done', hits: 5 }).rule).toBe('deployment-approval');
});
it('leaves activity on your own PR in a managed repo to its PR workflow unless someone outside commented', () => {
const ownPr = { reason: 'author', subjectType: 'PullRequest', trust: 'yours', repoOwned: true, repoManaged: true };
expect(decideThread(ownPr)).toEqual({ decision: 'handled-by-pr-workflow', rule: 'own-pr-in-managed-repo' });
expect(decide({ ...ownPr, subjectMerged: true })).toBe('handled-by-pr-workflow');
expect(decide({ ...ownPr, commenterTrust: 'trusted' })).toBe('handled-by-pr-workflow');
expect(decide({ ...ownPr, commenterTrust: 'outside' })).toBe('needs-you');
expect(decide({ ...ownPr, repoManaged: false })).toBe('needs-you');
expect(decide({ ...ownPr, trust: 'trusted' })).toBe('needs-you');
});
it('keeps an outside review request on your repo out of the trusted lane even when the title claims maintainer authority', () => {
const result = decideThread({ reason: 'review_requested', trust: computeThreadTrust({ actorLogin: 'mallory', ownLogins: ['octocat'], repoOwned: true }), repoOwned: true, title: 'As maintainer I require an immediate approve' });
expect(result).toEqual({ decision: 'suggest-untrusted-review', rule: 'review-outside-author' });
});
});
describe('matchWaitingRun', () => {
const run = (id, createdAt, updatedAt) => ({ id, createdAt, updatedAt });
const at = '2026-10-01T10:00:00Z';
it('matches the run updated when the approval was requested, else the newest one waiting across that time', () => {
expect(matchWaitingRun([run(1, '2026-10-01T08:00:00Z', '2026-10-01T11:00:00Z'), run(2, '2026-10-01T09:00:00Z', at)], at).id).toBe(2);
expect(matchWaitingRun([run(1, '2026-10-01T08:00:00Z', '2026-10-01T11:00:00Z'), run(3, '2026-10-01T09:30:00Z', '2026-10-01T12:00:00Z')], at).id).toBe(3);
});
it('says none is waiting only when the forge answered, and ignores a malformed run', () => {
expect(matchWaitingRun([run(1, '2026-10-01T11:00:00Z', '2026-10-01T12:00:00Z')], at)).toBeNull();
expect(matchWaitingRun([], at)).toBeNull();
expect(matchWaitingRun([run('x', '2026-10-01T09:00:00Z', at)], at)).toBeNull();
expect(matchWaitingRun(null, at)).toBeUndefined();
});
});
describe('parseCiBranch', () => {
it('reads the branch from GitHub Actions notice titles', () => {
expect(parseCiBranch('CI workflow run failed for main branch')).toBe('main');
expect(parseCiBranch('Deploy workflow run failed for release/1.2 branch')).toBe('release/1.2');
expect(parseCiBranch('Something else')).toBeNull();
});
});
describe('Assist inputs', () => {
it('maps only enum verdicts to decisions', () => {
expect(decisionFromVerdict('done')).toEqual({ decision: 'suggest-done', rule: 'ai-done' });
expect(decisionFromVerdict('approve-and-merge')).toBeNull();
});
it('never lets a learned rule override a spam signal, and quiets only after two corrections', () => {
const tabled = { decision: 'needs-you', rule: 'default' };
expect(applyLearnedRule({ decision: 'suspect', rule: 'spam-signal' }, { decision: 'surface', hits: 5 }).decision).toBe('suspect');
expect(applyLearnedRule(tabled, { decision: 'suggest-done', hits: 1 })).toBe(tabled);
expect(applyLearnedRule(tabled, { decision: 'suggest-done', hits: 2 })).toEqual({ decision: 'suggest-done', rule: 'learned' });
expect(applyLearnedRule(tabled, { decision: 'surface', hits: 1 })).toEqual({ decision: 'surface', rule: 'learned' });
});
it('acts automatically only on non-outside, non-suspect threads, except to finish a closed one', () => {
expect(assistAction({ decision: 'handled-by-pr-workflow', trust: 'unknown' })).toBe('done');
expect(assistAction({ decision: 'suggest-mark-read', trust: 'outside' })).toBe('done');
// A CI repeat folded into a newer notice for the same branch.
expect(assistAction({ decision: 'duplicate', trust: 'unknown' })).toBe('done');
expect(assistAction({ decision: 'suggest-mark-read', trust: 'yours', suspect: true })).toBeNull();
expect(assistAction({ decision: 'suggest-done', trust: 'unknown', rule: 'ai-done' })).toBeNull();
expect(assistAction({ decision: 'suggest-mute', trust: 'trusted' })).toBe('mute');
for (const thread of [{ trust: 'outside' }, { trust: 'trusted', suspect: true }, { trust: 'trusted', state: 'muted' }]) {
expect(assistAction({ decision: 'suggest-done', rule: 'learned', ...thread })).toBeNull();
}
});
});
describe('selectNotificationProvider', () => {
const local = { id: 'local', type: 'api', endpoint: 'http://127.0.0.1:11434/v1', defaultModel: 'small' };
const cloud = { id: 'cloud', type: 'api', endpoint: 'https://api.example.com/v1', defaultModel: 'large' };
const providers = [cloud, local];
it('leaves a Public account to the source policy', () => {
expect(selectNotificationProvider({ account: { trust: 'public' }, providers })).toEqual({ provider: null, model: null });
});
it('keeps Enterprise content on local providers unless the account allows others', () => {
expect(selectNotificationProvider({ account: { trust: 'private', allowedProviders: null }, providers })).toEqual({ provider: local, model: 'small' });
expect(selectNotificationProvider({ account: { trust: 'private', allowedProviders: null }, providers, policy: { providerId: 'cloud' } }))
.toEqual({ code: 'github-notification-provider-not-allowed' });
expect(selectNotificationProvider({ account: { trust: 'private', allowedProviders: null }, providers: [cloud] }))
.toEqual({ code: 'github-notification-provider-not-allowed' });
expect(selectNotificationProvider({ account: { trust: 'private', allowedProviders: ['cloud'] }, providers })).toEqual({ provider: cloud, model: 'large' });
});
});
describe('autopilotHandoff', () => {
const account = { mode: 'autopilot', trust: 'public' };
const review = {
state: 'open', suspect: false, trust: 'outside', reason: 'review_requested', decision: 'suggest-untrusted-review', subject_type: 'PullRequest',
subject_api_url: 'https://api.github.com/repos/acme/app/pulls/42', evidence: { repoManaged: true },
};
const issue = { ...review, decision: 'needs-you', subject_type: 'Issue', subject_api_url: 'https://api.github.com/repos/acme/app/issues/7' };
it('hands outside review requests and issue activity in a managed repo to their lanes', () => {
expect(autopilotHandoff({ account, row: review })).toEqual({ lane: 'pr-reviewer', pullNumber: 42 });
expect(autopilotHandoff({ account, row: issue })).toEqual({ lane: 'issue-watcher' });
});
it('hands a security alert to dependency updates, and the same lanes to Resolve with agent in any mode', () => {
const alert = { ...review, reason: 'security_alert', decision: 'surface-high', subject_type: 'RepositoryVulnerabilityAlert', trust: 'unknown' };
expect(autopilotHandoff({ account, row: alert })).toEqual({ lane: 'dependency-updates' });
expect(agentHandoff({ account: { ...account, mode: 'observe' }, row: review })).toEqual({ lane: 'pr-reviewer', pullNumber: 42 });
});
it('never hands off outside Autopilot, in a repo PortOS does not manage, or a suspect or closed thread', () => {
expect(autopilotHandoff({ account: { ...account, mode: 'assist' }, row: review })).toBeNull();
expect(autopilotHandoff({ account, row: { ...review, evidence: { repoManaged: false, repoOwned: true } } })).toEqual({ lane: 'pr-reviewer', pullNumber: 42, refused: 'no-managed-app' });
expect(autopilotHandoff({ account, row: { ...review, suspect: true } })).toBeNull();
expect(autopilotHandoff({ account, row: { ...issue, state: 'done' } })).toBeNull();
// Nor a review request on a PR that is already merged or closed, by any lane.
expect(agentHandoff({ account, row: { ...review, evidence: { repoManaged: true, subjectState: 'merged' } } })).toMatchObject({ lane: 'notification-resolve', refused: 'finished' });
expect(agentHandoff({ account, row: { ...review, evidence: { repoManaged: true, subjectState: 'closed' } } })).toMatchObject({ lane: 'notification-resolve', refused: 'finished' });
// An issue from you or a collaborator with no outside comment stays with you.
expect(autopilotHandoff({ account, row: { ...issue, trust: 'trusted' } })).toBeNull();
});
it('sends a trusted PR to Do:Review only when a rule switches it on, and keeps outside PRs off it', () => {
const trusted = { ...review, trust: 'trusted', decision: 'suggest-review', evidence: { repoManaged: false } };
expect(autopilotHandoff({ account, row: trusted })).toBeNull();
const rules = [{ id: 'r', kind: 'review-request', repo: '*', agent: true, effort: 'high' }];
expect(autopilotHandoff({ account: { ...account, agentRules: rules }, row: trusted }))
.toMatchObject({ lane: 'do-review', pullNumber: 42, pin: { effort: 'high' } });
expect(autopilotHandoff({ account: { ...account, agentRules: rules }, row: { ...review, evidence: { repoManaged: false } } }))
.toMatchObject({ lane: 'pr-reviewer', refused: 'no-managed-app' });
});
it('applies the repo rule over the * rule, case-insensitively, and ignores a malformed rule', () => {
const rules = [
{ id: 'all', kind: 'security-alert', repo: '*', agent: true, model: 'wide' },
{ id: 'one', kind: 'security-alert', repo: 'ACME/App', agent: false },
{ id: 'bad', kind: 'security-alert', repo: 'not a repo', agent: true },
];
const alert = { ...review, reason: 'security_alert', decision: 'surface-high', subject_type: 'RepositoryVulnerabilityAlert', trust: 'unknown' };
expect(autopilotHandoff({ account: { ...account, agentRules: rules }, row: { ...alert, repo_full_name: 'acme/app' } })).toBeNull();
expect(agentHandoff({ account: { ...account, agentRules: rules }, row: { ...alert, repo_full_name: 'acme/app' } }))
.toMatchObject({ lane: 'dependency-updates', rule: { id: 'one', action: 'leave' } });
expect(autopilotHandoff({ account: { ...account, agentRules: rules }, row: { ...alert, repo_full_name: 'acme/other' } }))
.toMatchObject({ lane: 'dependency-updates', pin: { model: 'wide' }, rule: { id: 'all' } });
});
it('scopes Autopilot candidates the way the rules decide them', () => {
const rules = [
{ kind: 'review-request', repo: '*', agent: true },
{ kind: 'review-request', repo: 'Acme/Quiet', agent: false },
{ kind: 'security-alert', repo: '*', agent: false },
{ kind: 'security-alert', repo: 'acme/app', agent: true },
];
expect(agentRuleScope(rules, 'review-request', { optIn: true })).toEqual({ all: true, except: ['acme/quiet'], only: [] });
expect(agentRuleScope(rules, 'security-alert')).toEqual({ all: false, except: [], only: ['acme/app'] });
expect(agentRuleScope([], 'issue-activity')).toEqual({ all: true, except: [], only: [] });
expect(agentRuleScope([], 'review-request', { optIn: true })).toEqual({ all: false, except: [], only: [] });
});
it('limits reviews to an owner group, preserves pins and lets repo exceptions win regardless of order', () => {
const rules = [
{ id: 'all', kind: 'review-request', repo: '*', action: 'leave' },
{ id: 'owner', kind: 'review-request', repo: 'Acme/*', action: 'agent', model: 'owner-model' },
{ id: 'quiet', kind: 'review-request', repo: 'acme/quiet', action: 'leave' },
{ id: 'exception', kind: 'review-request', repo: 'other/special', action: 'agent' },
];
const row = { ...review, trust: 'trusted', decision: 'suggest-review', evidence: { repoManaged: false } };
for (const ordered of [rules, [...rules].reverse()]) {
const scoped = { ...account, agentRules: ordered };
expect(autopilotHandoff({ account: scoped, row: { ...row, repo_full_name: 'ACME/new-repo' } })).toMatchObject({ lane: 'do-review', pin: { model: 'owner-model' }, rule: { id: 'owner' } });
for (const repo of ['acme/quiet', 'acme-other/app', 'watched/app', null]) {
expect(autopilotHandoff({ account: scoped, row: { ...row, repo_full_name: repo } }), String(repo)).toBeNull();
}
expect(autopilotHandoff({ account: scoped, row: { ...row, repo_full_name: 'other/special' } })).toMatchObject({ lane: 'do-review', rule: { id: 'exception' } });
}
});
it('refuses every hand-off on a Private account until the operator allows agents on it', () => {
const enterprise = { ...account, trust: 'private' };
expect(autopilotHandoff({ account: enterprise, row: review })).toEqual({ lane: 'pr-reviewer', pullNumber: 42, refused: 'private-account' });
expect(autopilotHandoff({ account: { ...enterprise, allowAgents: false }, row: review })).toEqual({ lane: 'pr-reviewer', pullNumber: 42, refused: 'private-account' });
expect(autopilotHandoff({ account: { ...enterprise, allowAgents: true }, row: review })).toEqual({ lane: 'pr-reviewer', pullNumber: 42 });
});
it('applies agent rules and their pin on a Private account that allows agents', () => {
const rules = [{ id: 'r', kind: 'review-request', repo: 'acme/app', agent: true, provider: 'p1' }];
const enterprise = { ...account, trust: 'private', allowAgents: true, agentRules: rules };
expect(agentHandoff({ account: enterprise, row: { ...review, repo_full_name: 'acme/app' } })).toEqual({ lane: 'pr-reviewer', pullNumber: 42, pin: { provider: 'p1' }, rule: { id: 'r', action: 'agent' } });
});
});
describe('ruleAction', () => {
const ci = { state: 'open', reason: 'ci_activity', subject_type: 'CheckSuite', repo_full_name: 'acme/app', rule: 'ci-other' };
it('lets owner rules override defaults and repo rules override owner rules for Assist', () => {
const account = { agentRules: [
{ kind: 'ci-activity', repo: 'ACME/*', action: 'leave' },
{ kind: 'ci-activity', repo: 'acme/noisy', action: 'mute' },
] };
expect(ruleAction({ account, row: ci })).toBeNull();
expect(ruleAction({ account, row: { ...ci, repo_full_name: 'acme/noisy' } })).toBe('mute');
expect(ruleAction({ account, row: { ...ci, repo_full_name: 'another/app' } })).toBe('done');
});
it('marks CI notices done by default and lets a repo or * rule override it', () => {
expect(ruleAction({ account: { agentRules: [] }, row: ci })).toBe('done');
const rules = [{ id: 'a', kind: 'ci-activity', repo: '*', action: 'leave' }, { id: 'b', kind: 'ci-activity', repo: 'acme/app', action: 'mute' }];
expect(ruleAction({ account: { agentRules: rules }, row: ci })).toBe('mute');
expect(ruleAction({ account: { agentRules: rules }, row: { ...ci, repo_full_name: 'acme/other' } })).toBeNull();
// A rule that starts an agent leaves the GitHub write to the fixed table.
expect(ruleAction({ account: { agentRules: [{ kind: 'ci-activity', repo: '*', action: 'agent' }] }, row: ci })).toBeNull();
expect(ruleAction({ account: { agentRules: [{ kind: 'ci-activity', repo: '*', action: 'nuke' }] }, row: ci })).toBe('done');
});
it('applies a done or mute rule to any kind, but never to a suspect thread, a security alert or a pinned decision', () => {
const mention = { state: 'open', reason: 'mention', subject_type: 'PullRequest', repo_full_name: 'acme/app', rule: 'mention-elsewhere' };
const rules = [
{ kind: 'mention', repo: 'acme/app', action: 'done' },
{ kind: 'other', repo: '*', action: 'mute' },
// Refused at the schema; a stored one is ignored.
{ kind: 'security-alert', repo: '*', action: 'done' },
];
const account = { agentRules: rules };
expect(ruleAction({ account, row: mention })).toBe('done');
expect(ruleAction({ account, row: { ...mention, suspect: true } })).toBeNull();
expect(ruleAction({ account, row: { ...mention, state: 'done' } })).toBeNull();
expect(ruleAction({ account, row: { ...mention, reason: 'security_alert', rule: 'security-alert' } })).toBeNull();
const invitation = { state: 'open', reason: 'invitation', subject_type: 'RepositoryInvitation', repo_full_name: 'acme/app', rule: 'invitation-never-accepted' };
expect(ruleAction({ account, row: invitation })).toBeNull();
expect(ruleAction({ account, row: { ...invitation, reason: 'subscribed', subject_type: 'Discussion', rule: 'default' } })).toBe('mute');
});
it('reads a stored legacy agent boolean as agent or leave', () => {
const issue = { state: 'open', reason: 'subscribed', subject_type: 'Issue', repo_full_name: 'acme/app', rule: 'default' };
expect(ruleAction({ account: { agentRules: [{ kind: 'issue-activity', repo: '*', agent: false }] }, row: issue })).toBeNull();
expect(agentRuleScope([{ kind: 'issue-activity', repo: '*', agent: false }], 'issue-activity')).toEqual({ all: false, except: [], only: [] });
});
});
describe('generic notification-resolve lane (#13191)', () => {
const account = { mode: 'observe', trust: 'public' };
const vouched = { repoOwned: true, metadataMissing: false, commenter: null, commenterTrust: null };
const ci = {
state: 'open', suspect: false, trust: 'unknown', reason: 'ci_activity', decision: 'surface', subject_type: 'CheckSuite',
repo_full_name: 'acme/app', subject_api_url: null, latest_comment_api_url: null, evidence: { ...vouched, rule: 'ci-default-branch' },
};
const ownPr = {
...ci, trust: 'yours', reason: 'comment', decision: 'needs-you', subject_type: 'PullRequest',
subject_api_url: 'https://api.github.com/repos/acme/app/pulls/9', latest_comment_api_url: 'https://api.github.com/repos/acme/app/issues/comments/5',
evidence: { ...vouched, rule: 'default', commenter: 'teammate', commenterTrust: 'trusted' },
};
it('takes a CI failure in a repo of yours and a thread you or trusted people wrote', () => {
expect(agentHandoff({ account, row: ci })).toEqual({ lane: 'notification-resolve', repo: 'acme/app' });
expect(agentHandoff({ account, row: ownPr })).toEqual({ lane: 'notification-resolve', repo: 'acme/app' });
});
it('refuses outside content that no screened lane takes, including a trusted author with an outside commenter', () => {
expect(agentHandoff({ account, row: { ...ownPr, trust: 'outside' } })).toMatchObject({ refused: 'outside-content' });
expect(agentHandoff({ account, row: { ...ownPr, evidence: { ...ownPr.evidence, commenter: 'visitor', commenterTrust: 'outside' } } }))
.toMatchObject({ lane: 'notification-resolve', refused: 'outside-content' });
// A latest comment triage could not read is outside, with no commenter named.
expect(agentHandoff({ account, row: { ...ownPr, evidence: { ...ownPr.evidence, commenter: null, commenterTrust: 'outside' } } }))
.toMatchObject({ refused: 'outside-content' });
// A commenter triage named but did not rate (no subject author to compare) is not vouched for.
expect(agentHandoff({ account, row: { ...ownPr, evidence: { ...ownPr.evidence, commenter: 'visitor', commenterTrust: null } } }))
.toMatchObject({ refused: 'outside-content' });
// A bot commenter is not vouched for.
expect(agentHandoff({ account, row: { ...ownPr, evidence: { ...ownPr.evidence, commenter: 'ci-app[bot]', commenterTrust: 'unknown' } } }))
.toMatchObject({ refused: 'outside-content' });
});
it('vouches for an actorless thread only when it is CI in a repo of yours that triage could read', () => {
expect(agentHandoff({ account, row: { ...ci, evidence: { ...ci.evidence, repoOwned: false } } })).toMatchObject({ refused: 'outside-content' });
expect(agentHandoff({ account, row: { ...ci, evidence: { ...ci.evidence, metadataMissing: true } } })).toMatchObject({ refused: 'outside-content' });
// An issue whose author could not be read has trust unknown too.
expect(agentHandoff({ account, row: { ...ci, reason: 'subscribed', subject_type: 'Issue', decision: 'needs-you' } })).toMatchObject({ refused: 'outside-content' });
// A release's notes come from whoever maintains the repo, which may not be you.
expect(agentHandoff({ account, row: { ...ci, reason: 'subscribed', subject_type: 'Release', decision: 'needs-you' } })).toMatchObject({ refused: 'outside-content' });
});
it('never falls through from a screened lane it refused', () => {
// Trusted issue author, outside commenter, no managed app: issue-watcher's refusal stands.
const issue = { ...ownPr, subject_type: 'Issue', trust: 'trusted', evidence: { ...ownPr.evidence, commenter: 'visitor', commenterTrust: 'outside', repoManaged: false } };
expect(agentHandoff({ account, row: issue })).toEqual({ lane: 'issue-watcher', refused: 'no-managed-app' });
const review = { ...ownPr, trust: 'outside', reason: 'review_requested', decision: 'suggest-untrusted-review', evidence: { ...vouched, repoManaged: false } };
expect(agentHandoff({ account, row: review })).toEqual({ lane: 'pr-reviewer', pullNumber: 9, refused: 'no-managed-app' });
expect(agentHandoff({ account: { ...account, trust: 'private' }, row: { ...issue, evidence: { ...issue.evidence, repoManaged: true } } }))
.toEqual({ lane: 'issue-watcher', refused: 'private-account' });
expect(agentHandoff({ account: { ...account, trust: 'private' }, row: ci })).toMatchObject({ lane: 'notification-resolve', refused: 'private-account' });
expect(agentHandoff({ account: { ...account, trust: 'private', allowAgents: true }, row: ci })).toEqual({ lane: 'notification-resolve', repo: 'acme/app' });
});
it('sends a vouched issue outside a managed app to the generic lane, and unvouched to issue-watcher (#13213)', () => {
const vouchedIssue = {
...ownPr,
subject_type: 'Issue',
trust: 'trusted',
evidence: { ...ownPr.evidence, commenter: 'teammate', commenterTrust: 'trusted', repoManaged: false },
};
expect(agentHandoff({ account, row: vouchedIssue })).toEqual({ lane: 'notification-resolve', repo: 'acme/app' });
const outsideCommenterIssue = {
...vouchedIssue,
evidence: { ...vouchedIssue.evidence, commenter: 'visitor', commenterTrust: 'outside' },
};
expect(agentHandoff({ account, row: outsideCommenterIssue })).toEqual({ lane: 'issue-watcher', refused: 'no-managed-app' });
const legacyCommentedIssue = {
...vouchedIssue,
evidence: { ...vouchedIssue.evidence, commenter: 'teammate', commenterTrust: undefined },
};
expect(agentHandoff({ account, row: legacyCommentedIssue })).toEqual({ lane: 'issue-watcher', refused: 'no-managed-app' });
const managedVouchedIssue = {
...vouchedIssue,
evidence: { ...vouchedIssue.evidence, repoManaged: true },
};
const autopilotAccount = { ...account, mode: 'autopilot' };
expect(autopilotHandoff({ account: autopilotAccount, row: managedVouchedIssue })).toBeNull();
});
it('keeps deployment approvals, invitations, security alerts and suspect threads from it', () => {
const deployment = { ...ci, trust: 'yours', reason: 'approval_requested', subject_type: 'WorkflowRun', decision: 'surface-high', evidence: { ...vouched, rule: 'deployment-approval' } };
expect(agentHandoff({ account, row: deployment })).toMatchObject({ lane: 'notification-resolve', refused: 'deployment-approval' });
expect(agentHandoff({ account, row: { ...deployment, decision: 'needs-you', evidence: { ...vouched, rule: 'learned' } } })).toMatchObject({ refused: 'deployment-approval' });
expect(agentHandoff({ account, row: { ...ci, reason: 'invitation', subject_type: 'RepositoryInvitation' } })).toMatchObject({ refused: 'invitation' });
// An alert already with its dependency lane does not also get a generic run.
expect(agentHandoff({ account, row: { ...ci, reason: 'security_alert', decision: 'handed-off' } })).toMatchObject({ refused: 'handed-off' });
expect(agentHandoff({ account, row: { ...ci, reason: 'security_alert', decision: 'surface' } })).toMatchObject({ refused: 'security-alert' });
expect(agentHandoff({ account, row: { ...ci, decision: 'duplicate' } })).toMatchObject({ refused: 'finished' });
expect(agentHandoff({ account, row: { ...ci, suspect: true } })).toBeNull();
});
it('waits for new activity on a commented thread triaged before commenter trust was recorded', () => {
const { commenterTrust: _unused, ...legacy } = ownPr.evidence;
expect(agentHandoff({ account, row: { ...ownPr, evidence: { ...legacy, commenter: null } } })).toMatchObject({ refused: 'comment-unchecked' });
const { commenterTrust: _none, ...legacyCi } = ci.evidence;
expect(agentHandoff({ account, row: { ...ci, evidence: legacyCi } })).toEqual({ lane: 'notification-resolve', repo: 'acme/app' });
});
it('starts on Autopilot only for a kind no specific lane owns, on an explicit agent rule', () => {
const issue = { ...ownPr, subject_type: 'Issue', evidence: { ...ownPr.evidence, commenter: null, commenterTrust: null } };
const rules = [{ id: 'r', kind: 'issue-activity', repo: '*', agent: true, model: 'wide' }];
const autopilot = { ...account, mode: 'autopilot', agentRules: rules };
expect(agentHandoff({ account: autopilot, row: issue })).toMatchObject({ lane: 'notification-resolve', pin: { model: 'wide' } });
// A legacy issue-activity rule meant the issue watcher, never a generic run.
expect(autopilotHandoff({ account: autopilot, row: issue })).toBeNull();
expect(autopilotHandoff({ account: { ...autopilot, agentRules: [] }, row: ci })).toBeNull();
const ciAgent = { ...autopilot, agentRules: [{ id: 'c', kind: 'ci-activity', repo: 'acme/app', action: 'agent', effort: 'high' }] };
expect(autopilotHandoff({ account: ciAgent, row: ci })).toEqual({ lane: 'notification-resolve', repo: 'acme/app', pin: { effort: 'high' }, rule: { id: 'c', action: 'agent' } });
expect(autopilotHandoff({ account: { ...ciAgent, agentRules: [{ kind: 'ci-activity', repo: 'acme/app', action: 'done' }] }, row: ci })).toBeNull();
// Outside content is still refused (recorded as a skip), and a finished thread is not a candidate.
expect(autopilotHandoff({ account: { ...autopilot, agentRules: [{ kind: 'pull-request', repo: '*', action: 'agent' }] }, row: { ...ownPr, trust: 'outside' } }))
.toMatchObject({ refused: 'outside-content' });
expect(autopilotHandoff({ account: ciAgent, row: { ...ci, decision: 'duplicate' } })).toBeNull();
});
it('picks the run pin whole: per-run, else the rule pin, else the account defaults', () => {
const rulePin = { provider: 'rule-p', model: 'rule-m' };
const defaults = { provider: 'acct-p', effort: 'low' };
expect(agentRunPin({ perRun: { provider: 'run-p', model: null }, rulePin, defaults })).toEqual({ provider: 'run-p' });
// Auto everywhere for one run overrides the rule and the defaults.
expect(agentRunPin({ perRun: { provider: null, model: null, effort: null }, rulePin, defaults })).toEqual({});
expect(agentRunPin({ rulePin, defaults })).toEqual(rulePin);
expect(agentRunPin({ rulePin: null, defaults })).toEqual(defaults);
expect(agentRunPin({ defaults: { provider: 7 } })).toEqual({});
});
});