
PACT
Orchestration harness that coordinates 14 specialist agents across a Claude Code session.
- version
- 4.8.35
- GitHub stars
- 73
What it does
- Adds 14 agents (
pact-architect,pact-backend-coder,pact-test-engineer,pact-orchestrator, and more) plus 14 commands such as/orchestrate,/comPACT, and/pause - Covers the full build flow: prepare, design, code, test, and audit, with
/peer-reviewand/wrap-upfor closing out work - Enforces dispatch and handoff order through hooks such as
handoff_ordering_gate,task_claim_gate, andmerge_guard_pre - Designed for developers who want a managed team of agents with persistent memory and durable session state inside Claude Code
Orchestration harness that turns Claude Code into a coordinated team of specialist AI agents
Add marketplace
/plugin marketplace add Synaptic-Labs-AI/PACT-PluginRun it inside Claude Code once, then install the plugin below.
Install
/plugin install PACT@pact-pluginRun it inside Claude Code after adding the marketplace.
Files
Discovered from sourceJavaScript Code Node
Expert guidance for writing JavaScript code in n8n Code nodes.
Quick Start
// Basic template for Code nodes
const items = $input.all();
// Process data
const processed = items.map(item => ({
json: {
...item.json,
processed: true,
timestamp: new Date().toISOString()
}
}));
return processed;
Essential Rules
- Choose "Run Once for All Items" mode (recommended for most use cases)
- Access data:
$input.all(),$input.first(), or$input.item - CRITICAL: Must return
[{json: {...}}]format - CRITICAL: Webhook data is under
$json.body(not$jsondirectly) - Built-ins available: $helpers.httpRequest(), DateTime (Luxon), $jmespath()
Mode Selection Guide
The Code node offers two execution modes. Choose based on your use case:
Run Once for All Items (Recommended - Default)
Use this mode for: 95% of use cases
- How it works: Code executes once regardless of input count
- Data access:
$input.all()oritemsarray - Best for: Aggregation, filtering, batch processing, transformations, API calls with all data
- Performance: Faster for multiple items (single execution)
// Example: Calculate total from all items
const allItems = $input.all();
const total = allItems.reduce((sum, item) => sum + (item.json.amount || 0), 0);
return [{
json: {
total,
count: allItems.length,
average: total / allItems.length
}
}];
When to use:
- ✅ Comparing items across the dataset
- ✅ Calculating totals, averages, or statistics
- ✅ Sorting or ranking items
- ✅ Deduplication
- ✅ Building aggregated reports
- ✅ Combining data from multiple items
Run Once for Each Item
Use this mode for: Specialized cases only
- How it works: Code executes separately for each input item
- Data access:
$input.itemor$item - Best for: Item-specific logic, independent operations, per-item validation
- Performance: Slower for large datasets (multiple executions)
// Example: Add processing timestamp to each item
const item = $input.item;
return [{
json: {
...item.json,
processed: true,
processedAt: new Date().toISOString()
}
}];
When to use:
- ✅ Each item needs independent API call
- ✅ Per-item validation with different error handling
- ✅ Item-specific transformations based on item properties
- ✅ When items must be processed separately for business logic
Decision Shortcut:
- Need to look at multiple items? → Use "All Items" mode
- Each item completely independent? → Use "Each Item" mode
- Not sure? → Use "All Items" mode (you can always loop inside)
Data Access Patterns
Pattern 1: $input.all() - Most Common
Use when: Processing arrays, batch operations, aggregations
// Get all items from previous node
const allItems = $input.all();
// Filter, map, reduce as needed
const valid = allItems.filter(item => item.json.status === 'active');
const mapped = valid.map(item => ({
json: {
id: item.json.id,
name: item.json.name
}
}));
return mapped;
Pattern 2: $input.first() - Very Common
Use when: Working with single objects, API responses, first-in-first-out
// Get first item only
const firstItem = $input.first();
const data = firstItem.json;
return [{
json: {
result: processData(data),
processedAt: new Date().toISOString()
}
}];
Pattern 3: $input.item - Each Item Mode Only
Use when: In "Run Once for Each Item" mode
// Current item in loop (Each Item mode only)
const currentItem = $input.item;
return [{
json: {
...currentItem.json,
itemProcessed: true
}
}];
Pattern 4: $node - Reference Other Nodes
Use when: Need data from specific nodes in workflow
// Get output from specific node
const webhookData = $node["Webhook"].json;
const httpData = $node["HTTP Request"].json;
return [{
json: {
combined: {
webhook: webhookData,
api: httpData
}
}
}];
See: DATA_ACCESS.md for comprehensive guide
Critical: Webhook Data Structure
MOST COMMON MISTAKE: Webhook data is nested under .body
// ❌ WRONG - Will return undefined
const name = $json.name;
const email = $json.email;
// ✅ CORRECT - Webhook data is under .body
const name = $json.body.name;
const email = $json.body.email;
// Or with $input
const webhookData = $input.first().json.body;
const name = webhookData.name;
Why: Webhook node wraps all request data under body property. This includes POST data, query parameters, and JSON payloads.
See: DATA_ACCESS.md for full webhook structure details
Return Format Requirements
CRITICAL RULE: Always return array of objects with json property
Correct Return Formats
// ✅ Single result
return [{
json: {
field1: value1,
field2: value2
}
}];
// ✅ Multiple results
return [
{json: {id: 1, data: 'first'}},
{json: {id: 2, data: 'second'}}
];
// ✅ Transformed array
const transformed = $input.all()
.filter(item => item.json.valid)
.map(item => ({
json: {
id: item.json.id,
processed: true
}
}));
return transformed;
// ✅ Empty result (when no data to return)
return [];
// ✅ Conditional return
if (shouldProcess) {
return [{json: processedData}];
} else {
return [];
}
Incorrect Return Formats
// ❌ WRONG: Object without array wrapper
return {
json: {field: value}
};
// ❌ WRONG: Array without json wrapper
return [{field: value}];
// ❌ WRONG: Plain string
return "processed";
// ❌ WRONG: Raw data without mapping
return $input.all(); // Missing .map()
// ❌ WRONG: Incomplete structure
return [{data: value}]; // Should be {json: value}
Why it matters: Next nodes expect array format. Incorrect format causes workflow execution to fail.
See: ERROR_PATTERNS.md #3 for detailed error solutions
Common Patterns Overview
Based on production workflows, here are the most useful patterns:
1. Multi-Source Data Aggregation
Combine data from multiple APIs, webhooks, or nodes
const allItems = $input.all();
const results = [];
for (const item of allItems) {
const sourceName = item.json.name || 'Unknown';
// Parse source-specific structure
if (sourceName === 'API1' && item.json.data) {
results.push({
json: {
title: item.json.data.title,
source: 'API1'
}
});
}
}
return results;
2. Filtering with Regex
Extract patterns, mentions, or keywords from text
const pattern = /\b([A-Z]{2,5})\b/g;
const matches = {};
for (const item of $input.all()) {
const text = item.json.text;
const found = text.match(pattern);
if (found) {
found.forEach(match => {
matches[match] = (matches[match] || 0) + 1;
});
}
}
return [{json: {matches}}];
3. Data Transformation & Enrichment
Map fields, normalize formats, add computed fields
const items = $input.all();
return items.map(item => {
const data = item.json;
const nameParts = data.name.split(' ');
return {
json: {
first_name: nameParts[0],
last_name: nameParts.slice(1).join(' '),
email: data.email,
created_at: new Date().toISOString()
}
};
});
4. Top N Filtering & Ranking
Sort and limit results
const items = $input.all();
const topItems = items
.sort((a, b) => (b.json.score || 0) - (a.json.score || 0))
.slice(0, 10);
return topItems.map(item => ({json: item.json}));
5. Aggregation & Reporting
Sum, count, group data
const items = $input.all();
const total = items.reduce((sum, item) => sum + (item.json.amount || 0), 0);
return [{
json: {
total,
count: items.length,
average: total / items.length,
timestamp: new Date().toISOString()
}
}];
See: COMMON_PATTERNS.md for 10 detailed production patterns
Error Prevention - Top 5 Mistakes
#1: Empty Code or Missing Return (Most Common)
// ❌ WRONG: No return statement
const items = $input.all();
// ... processing code ...
// Forgot to return!
// ✅ CORRECT: Always return data
const items = $input.all();
// ... processing ...
return items.map(item => ({json: item.json}));
#2: Expression Syntax Confusion
// ❌ WRONG: Using n8n expression syntax in code
const value = "{{ $json.field }}";
// ✅ CORRECT: Use JavaScript template literals
const value = `${$json.field}`;
// ✅ CORRECT: Direct access
const value = $input.first().json.field;
#3: Incorrect Return Wrapper
// ❌ WRONG: Returning object instead of array
return {json: {result: 'success'}};
// ✅ CORRECT: Array wrapper required
return [{json: {result: 'success'}}];
#4: Missing Null Checks
// ❌ WRONG: Crashes if field doesn't exist
const value = item.json.user.email;
// ✅ CORRECT: Safe access with optional chaining
const value = item.json?.user?.email || 'no-email@example.com';
// ✅ CORRECT: Guard clause
if (!item.json.user) {
return [];
}
const value = item.json.user.email;
#5: Webhook Body Nesting
// ❌ WRONG: Direct access to webhook data
const email = $json.email;
// ✅ CORRECT: Webhook data under .body
const email = $json.body.email;
See: ERROR_PATTERNS.md for comprehensive error guide
Built-in Functions & Helpers
$helpers.httpRequest()
Make HTTP requests from within code:
const response = await $helpers.httpRequest({
method: 'GET',
url: 'https://api.example.com/data',
headers: {
'Authorization': 'Bearer token',
'Content-Type': 'application/json'
}
});
return [{json: {data: response}}];
DateTime (Luxon)
Date and time operations:
// Current time
const now = DateTime.now();
// Format dates
const formatted = now.toFormat('yyyy-MM-dd');
const iso = now.toISO();
// Date arithmetic
const tomorrow = now.plus({days: 1});
const lastWeek = now.minus({weeks: 1});
return [{
json: {
today: formatted,
tomorrow: tomorrow.toFormat('yyyy-MM-dd')
}
}];
$jmespath()
Query JSON structures:
const data = $input.first().json;
// Filter array
const adults = $jmespath(data, 'users[?age >= `18`]');
// Extract fields
const names = $jmespath(data, 'users[*].name');
return [{json: {adults, names}}];
See: BUILTIN_FUNCTIONS.md for complete reference
Best Practices
1. Always Validate Input Data
const items = $input.all();
// Check if data exists
if (!items || items.length === 0) {
return [];
}
// Validate structure
if (!items[0].json) {
return [{json: {error: 'Invalid input format'}}];
}
// Continue processing...
2. Use Try-Catch for Error Handling
try {
const response = await $helpers.httpRequest({
url: 'https://api.example.com/data'
});
return [{json: {success: true, data: response}}];
} catch (error) {
return [{
json: {
success: false,
error: error.message
}
}];
}
3. Prefer Array Methods Over Loops
// ✅ GOOD: Functional approach
const processed = $input.all()
.filter(item => item.json.valid)
.map(item => ({json: {id: item.json.id}}));
// ❌ SLOWER: Manual loop
const processed = [];
for (const item of $input.all()) {
if (item.json.valid) {
processed.push({json: {id: item.json.id}});
}
}
4. Filter Early, Process Late
// ✅ GOOD: Filter first to reduce processing
const processed = $input.all()
.filter(item => item.json.status === 'active') // Reduce dataset first
.map(item => expensiveTransformation(item)); // Then transform
// ❌ WASTEFUL: Transform everything, then filter
const processed = $input.all()
.map(item => expensiveTransformation(item)) // Wastes CPU
.filter(item => item.json.status === 'active');
5. Use Descriptive Variable Names
// ✅ GOOD: Clear intent
const activeUsers = $input.all().filter(item => item.json.active);
const totalRevenue = activeUsers.reduce((sum, user) => sum + user.json.revenue, 0);
// ❌ BAD: Unclear purpose
const a = $input.all().filter(item => item.json.active);
const t = a.reduce((s, u) => s + u.json.revenue, 0);
6. Debug with console.log()
// Debug statements appear in browser console
const items = $input.all();
console.log(`Processing ${items.length} items`);
for (const item of items) {
console.log('Item data:', item.json);
// Process...
}
return result;
When to Use Code Node
Use Code node when:
- ✅ Complex transformations requiring multiple steps
- ✅ Custom calculations or business logic
- ✅ Recursive operations
- ✅ API response parsing with complex structure
- ✅ Multi-step conditionals
- ✅ Data aggregation across items
Consider other nodes when:
- ❌ Simple field mapping → Use Set node
- ❌ Basic filtering → Use Filter node
- ❌ Simple conditionals → Use IF or Switch node
- ❌ HTTP requests only → Use HTTP Request node
Code node excels at: Complex logic that would require chaining many simple nodes
Integration with Other Skills
Works With:
n8n Expression Syntax:
- Expressions use
{{ }}syntax in other nodes - Code nodes use JavaScript directly (no
{{ }}) - When to use expressions vs code
n8n MCP Tools Expert:
- How to find Code node:
search_nodes({query: "code"}) - Get configuration help:
get_node_essentials("nodes-base.code") - Validate code:
validate_node_operation()
n8n Node Configuration:
- Mode selection (All Items vs Each Item)
- Language selection (JavaScript vs Python)
- Understanding property dependencies
n8n Workflow Patterns:
- Code nodes in transformation step
- Webhook → Code → API pattern
- Error handling in workflows
n8n Validation Expert:
- Validate Code node configuration
- Handle validation errors
- Auto-fix common issues
Quick Reference Checklist
Before deploying Code nodes, verify:
- Code is not empty - Must have meaningful logic
- Return statement exists - Must return array of objects
- Proper return format - Each item:
{json: {...}} - Data access correct - Using
$input.all(),$input.first(), or$input.item - No n8n expressions - Use JavaScript template literals:
`${value}` - Error handling - Guard clauses for null/undefined inputs
- Webhook data - Access via
.bodyif from webhook - Mode selection - "All Items" for most cases
- Performance - Prefer map/filter over manual loops
- Output consistent - All code paths return same structure
Additional Resources
Related Files
- DATA_ACCESS.md - Comprehensive data access patterns
- COMMON_PATTERNS.md - 10 production-tested patterns
- ERROR_PATTERNS.md - Top 5 errors and solutions
- BUILTIN_FUNCTIONS.md - Complete built-in reference
n8n Documentation
- Code Node Guide: https://docs.n8n.io/code/code-node/
- Built-in Methods: https://docs.n8n.io/code-examples/methods-variables-reference/
- Luxon Documentation: https://moment.github.io/luxon/
Ready to write JavaScript in n8n Code nodes! Start with simple transformations, use the error patterns guide to avoid common mistakes, and reference the pattern library for production-ready examples.
Readme
PACT — Orchestration Harness for Claude Code
Version: 4.8.35
Turn a single Claude Code session into a managed team of specialist AI agents that prepare, design, build, and test your code systematically.
Breaking change in v4.0: PACT now delivers the orchestrator persona via the
--agent PACT:pact-orchestratorflag (or settings.json /pactscript convention) instead of CLAUDE.md routing. See the v4.0 upgrade guide for details — also requires Agent Teams enabled per v3.0+.
Install in 30 Seconds
/plugin marketplace add Synaptic-Labs-AI/PACT-Plugin
/plugin install PACT@pact-plugin
cp ~/.claude/plugins/cache/pact-plugin/PACT/*/CLAUDE.md ~/.claude/CLAUDE.md
Then add ~/.claude/teams and ~/.claude/pact-sessions to your additionalDirectories and PACT allow rules in ~/.claude/settings.json to prevent permission prompts during agent operations:
{
"env": {
"CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1",
"CLAUDE_CODE_ENABLE_TODO_TOOLS": "1"
},
"permissions": {
"additionalDirectories": [
"~/.claude/teams",
"~/.claude/pact-sessions"
],
"allow": [
"Write(~/.claude/agent-memory/**)",
"Read(~/.claude/agent-memory/**)",
"Edit(~/.claude/agent-memory/**)",
"Write(~/.claude/pact-sessions/**)",
"Read(~/.claude/pact-sessions/**)",
"Edit(~/.claude/pact-sessions/**)",
"Write(~/.claude/pact-memory/**)",
"Read(~/.claude/pact-memory/**)",
"Edit(~/.claude/pact-memory/**)",
"Write(~/.claude/pact-telegram/**)",
"Read(~/.claude/pact-telegram/**)",
"Edit(~/.claude/pact-telegram/**)"
]
}
}
Note: Bash allow rules are intentionally omitted — they are fragile for commands with arguments. When agents run
mkdirorrmin~/.claude/paths, select "Yes, and always allow from this project" to add the rule automatically.
The two env values are prerequisites and they gate different things: Agent Teams, and the task tools PACT must have to bootstrap. If specialists will not spawn, see If specialist agents will not spawn.
If spawned specialists report Task tools missing, follow current Agent Team dispatch recovery below rather than inferring a spawn-mode cause. The ordered checks cover deferred tools, lead-session settings, the live Agent schema, named-teammate creation, display mode, and messaging.
Then restart Claude Code. Requires Agent Teams enabled and the --agent flag wired up — see Loading PACT at session start for the three convenience patterns (per-project .claude/settings.json, the pact shell wrapper, or manual claude --agent PACT:pact-orchestrator).
Current Agent Team dispatch recovery
Use this ordered tree for a dispatch or messaging failure. Roles are explicit: the affected teammate self-helps in A and relays in G; the lead owns B–F and the final blocker report. Do not start with a respawn, and do not treat a harness label as proof of the cause.
A. Load deferred tools. The actor missing Task tools runs ToolSearch "select:TaskCreate,TaskUpdate,TaskList,TaskGet,SendMessage" when it has not already run. If a teammate's tools load, it continues without a respawn. If they remain absent, the teammate reports the exact missing tools and load result to its lead when messaging permits, then stops implementation work and idles while the lead continues below. The lead's own successful ToolSearch proves only the lead's tool surface, never the teammate's.
B. Check the lead session. The lead checks its own four Task tools. If they are missing, the lead fixes the session opt-in/settings and must start the required new session. Never respawn a teammate for this cause; the teammate does not restart the session.
C. Compare the call with the live Agent schema. The lead compares its dispatch with the live schema. Current teammate creation requires an interactive session, agent teams enabled, and a named, non-fork, non-isolation Agent call. The lead corrects Task(...), a missing name, fork/isolation, or non-interactive -p usage. Never add a parameter absent from the live schema or substitute subagent-definition frontmatter for an Agent argument; the teammate does not rewrite the lead's call.
D. Confirm named-teammate creation and addressability. The lead uses platform spawn, roster, and messaging evidence, including the teammate's exact report. A missing config.json alone is not failure in a config-less cloud session. A named -p agent is an ordinary subagent, not evidence of team formation; the lead corrects team enablement/registration instead.
E. Apply display-mode inheritance. The lead checks the actual teammate display mode. In-process teammates follow the lead session. For split-pane, the lead checks --tools/deny rules and environment forwarding through --settings, then corrects launch configuration before replacement; the teammate does not change it.
F. Use the legacy-only branch only after A–E. For an older non-TTY runtime exhibiting the #1658 symptom, only the lead follows the single operational legacy note in pact-plugin/README.md; the teammate never applies legacy dispatch. Do not copy its dispatch template into current guidance or treat schema presence alone as lifecycle evidence.
G. Relay residual structured content. If Task tools remain absent but SendMessage reaches team-lead or main, the teammate relays the teachback/HANDOFF content and the lead writes metadata. Acceptance/rejection ordering is unchanged; no hook suppression logic or relay marker is involved, and no respawn loop follows.
H. Stop on messaging failure. If SendMessage is also unavailable or unreachable, the teammate cannot relay and stops/idles. The lead reports the team-formation/messaging blocker with the evidence gathered above.
Legacy non-TTY compatibility note
This is not current dispatch guidance. It is only for an older non-TTY runtime exhibiting the #1658 Task-tool-loss symptom. Do not copy it into current Agent blocks; it never permits an Agent background replacement.
- Confirm that the runtime is an older non-TTY environment exhibiting the #1658 Task-tool-loss symptom.
- Complete current recovery branches A–E.
- Confirm that the live Agent schema exposes
run_in_background. Schema presence is expressibility, not necessity; alone it neither satisfies this branch nor proves lifecycle support or justifies respawn. - Only then, the measured #1658
run_in_background: falseworkaround MAY be used. - Verify the result with a post-spawn
TaskListcheck, and require a full teachback → work → HANDOFF → completion ceremony before any support claim.
What You Get
- 12 Specialist Agents — Preparer, Architect, Backend/Frontend/Database/DevOps Coders, n8n, Test/Security/QA Engineers, Auditor (concurrent observation during CODE), Secretary
- 12 Commands — From full orchestration (
/PACT:orchestrate) to quick single-specialist fixes (/PACT:comPACT), plus pause/resume (/PACT:pause) and pin-memory management (/PACT:pin-memory,/PACT:prune-memory) - 20 Skills — On-demand domain knowledge for architecture, coding, testing, security, n8n, plus operational skills (agent teams, teachback, handoff harvest, memory, worktree)
- Persistent Memory — SQLite + vector embeddings for cross-session learning; additive list merge so lessons grow monotonically
- Durable Workflow State — Append-only session journal (
~/.claude/pact-sessions/) survives compaction, task GC, and crashes - Adaptive Complexity — Light process for simple tasks, full ceremony for complex ones; calibration data feeds back into variety scoring (Bateson's Learning II)
- Safety Discipline — Harness-Origin Distinction (harness-origin text ≠ user consent), two-call atomic acceptance pair, structural verification against
git diffground truth
Quick Start
/PACT:orchestrate <task> # Full multi-agent workflow
/PACT:comPACT <domain> <task> # Self-contained tasks, no PACT phases
/PACT:plan-mode <task> # Strategic planning before implementation
/PACT:pause # Consolidate memory, persist state, shut down teammates
What's New in v4.0+
--agentflag persona delivery: Orchestrator persona ships at the system-prompt tier via--agent PACT:pact-orchestrator, durable under context compaction (replaces v3.x CLAUDE.md routing)- Lazy-load protocols: Persona body cross-references protocols on demand instead of bootstrapping them all up front, reducing baseline token cost
- Restored session-start ritual (v4.1): Scaled-down
/PACT:bootstrapcommand +bootstrap_gate.pyinjection re-establish the first-turn ritual under the new delivery model - Communication Charter: Async-at-idle-boundary delivery model formalized for inter-agent
SendMessagemechanics - Concurrent Audit (v4.2): Auditor agent observes CODE phase via
git diffrather than messaging — catches architecture drift before it compounds, with structural verification discipline against ground truth
Configuration
Environment variables that tune PACT behavior. Full detail — types, precedence, and the two settings.json gotchas — is in reference/config.md.
| Variable | Default | Allowed values | Effect |
|---|---|---|---|
PACT_PR_GREEDY_FIX | 0 (off) | 1 / 0 | When on, peer-review greedily auto-delegates all minor + future reviewer findings as reversible fixes; merge / close / push stay user-gated and SACROSANCT is never overridden. Off = the default per-finding review gate. |
PACT_AUTONOMOUS_SCOPE_DETECTION | 0 (off) | 1 / 0 | When on, scope detection may auto-decompose without user confirmation when all strong signals fire. Off = the Confirmed tier (proposes; user confirms). Replaces the retired autonomous-scope-detection: enabled CLAUDE.md marker. |
PACT_DISPATCH_INLINE_MISSION_MODE | warn | warn / deny / shadow | Disposition of the dispatch-gate inline-mission heuristic (flags dispatchers inlining mission text into prompt= instead of using the canonical "check TaskList" form). warn emits an advisory additionalContext; deny blocks the spawn (flip only after empirically confirming additionalContext injection is reliable under PreToolUse — see pact-plugin/hooks/dispatch_gate.py for the matcher-fidelity discussion); shadow journals only — the trigger is observable but neither WARNs nor DENYs (calibration / first-session safety net). The other dispatch-gate rules (name/team presence, name validation, specialist registry, session-team match, member uniqueness, task-assignment) are unaffected by this env-var. Unknown values fall back to warn. |
PACT_DISPATCH_VARIETY_MODE | deny | warn / deny / shadow | Disposition of the handoff-ordering dispatch-variety enforcement — the one option that ships ENFORCING: a dispatch-wiring TaskUpdate whose Task B carries no resolvable metadata.variety is blocked. Set warn (advisory additionalContext) or shadow (journal only) to opt down. An UNSET variable enforces; an UNRECOGNIZED one falls back to warn (the row's declared invalid_fallback) with a stderr line naming what it resolved to — absence is consent to the shipped posture, an unparseable value is not. |
Bool options parse 1 / true / yes / on → on; everything else (including 0 and unset) → off.
Full Documentation
For installation options, detailed features, examples, and technical reference: github.com/Synaptic-Labs-AI/PACT-Plugin
Reference
- Protocols — 22 coordination protocols (scope detection, algedonic signals, audit, state recovery)
- Algedonic Signals — Emergency escalation protocol
- Communication Charter — Async-at-idle-boundary inter-agent delivery model
- Completion Authority — Lead-only completion + Task A+B dispatch shape
- Concurrent Audit — Auditor observation cycles and structural verification discipline
- State Recovery — Resume + recovery semantics across sessions
- S5 Policy — Non-negotiable rules layer (security, quality, ethics, integrity)
- S4 Tension — Strategic-vs-operational tension management
- VSM Glossary — Viable System Model terminology in PACT context
License
MIT — See LICENSE
Details
- Marketplace
- Synaptic-Labs-AI/PACT-Plugin
- Source
- pact-plugin
- Author
- Synaptic-Labs-AI
- Category
- Development
- License
- MIT
- Keywords
- pact, vsm, viable-system-model, agents, orchestration, development, architecture, testing, n8n
Similar to PACT
More Development Tools
reamorluto/rea466.8K starsReverse engineer anything with agents, from app behavior down to native binaries.
superpowersobra/superpowers319.5K starsCore skills library for Claude Code: TDD, debugging, collaboration patterns, and proven techniques
claude-apianthropics/skills196.9K starsClaude API and SDK documentation skill for building LLM-powered applications
prompts.chatf/prompts.chat178.2K starsAccess thousands of AI prompts and skills directly in your AI coding assistant. Search prompts, discover skills, save your own, and improve prompts with AI.
agent-sdk-devanthropics/claude-code156.1K starsDevelopment kit for working with the Claude Agent SDK
ui-ux-pro-maxnextlevelbuilder/ui-ux-pro-max-skill152.6K starsProfessional UI/UX design intelligence for AI coding assistants. Includes searchable databases of styles, colors, typography, charts, and UX guidelines for Reac