New advertisers: 50% off your first month with code FIRSTMONTHSee slots
Synaptic-Labs-AI avatar

PACT

Synaptic-Labs-AI/PACT-Plugin

Orchestration harness that coordinates 14 specialist agents across a Claude Code session.

version
4.8.35
GitHub stars
73
View on GitHub

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-review and /wrap-up for closing out work
  • Enforces dispatch and handoff order through hooks such as handoff_ordering_gate, task_claim_gate, and merge_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-Plugin

Run it inside Claude Code once, then install the plugin below.

Install

/plugin install PACT@pact-plugin

Run it inside Claude Code after adding the marketplace.

Files

Discovered from source
pact-security-patternspact-teachbackpact-team-registrationpact-testing-strategiesrequest-more-contexttelegram-guideworktree-cleanupworktree-setup

JavaScript 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

  1. Choose "Run Once for All Items" mode (recommended for most use cases)
  2. Access data: $input.all(), $input.first(), or $input.item
  3. CRITICAL: Must return [{json: {...}}] format
  4. CRITICAL: Webhook data is under $json.body (not $json directly)
  5. 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() or items array
  • 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.item or $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 .body if 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

n8n Documentation


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-orchestrator flag (or settings.json / pact script 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 mkdir or rm in ~/.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.

  1. Confirm that the runtime is an older non-TTY environment exhibiting the #1658 Task-tool-loss symptom.
  2. Complete current recovery branches A–E.
  3. 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.
  4. Only then, the measured #1658 run_in_background: false workaround MAY be used.
  5. Verify the result with a post-spawn TaskList check, 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 diff ground 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+

  • --agent flag 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:bootstrap command + bootstrap_gate.py injection re-establish the first-turn ritual under the new delivery model
  • Communication Charter: Async-at-idle-boundary delivery model formalized for inter-agent SendMessage mechanics
  • Concurrent Audit (v4.2): Auditor agent observes CODE phase via git diff rather 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.

VariableDefaultAllowed valuesEffect
PACT_PR_GREEDY_FIX0 (off)1 / 0When 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_DETECTION0 (off)1 / 0When 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_MODEwarnwarn / deny / shadowDisposition 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_MODEdenywarn / deny / shadowDisposition 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