@voybio/ace-swarm 0.1.0

package/assets/tasks/lessons.md

@@ -0,0 +1,17 @@
+# ACE Lessons & Guardrails
+
+Use this file as an append-only guardrail ledger.
+
+## Template
+
+- **Date:** YYYY-MM-DD
+- **Context:** <where the failure happened>
+- **Failure Pattern:** <what went wrong>
+- **Guardrail:** Never <bad pattern>; always <safe pattern>.
+- **Verification Check:** <objective way to enforce the guardrail>
+
+## Seed Guardrails
+
+- Never close implementation work without objective verification output.
+- Never route cross-role work without a structured handoff payload.
+- Never mark a task done when artifact updates are missing.

package/assets/tasks/role_tasks.md

@@ -0,0 +1,206 @@
+# ACE Role Task Packs
+
+## ACE-Orchestrator Task Pack
+
+- Maintain global routing across venture, UX, and engineering tracks.
+- Keep execution state synchronized (`MASTER_PLAN`, blockers, risks, handoffs).
+- Decompose work into bounded tasks with measurable acceptance criteria.
+- Enforce artifact-first completion and explicit verification evidence.
+
+**Required evidence**
+
+- Updated plan/status artifact.
+- Handoff payloads with context pointers.
+- Explicit next state: done/blocked/rerouted.
+
+## ACE-VOS Task Pack
+
+- Harden raw ideas into thesis, architecture blueprint, and growth loops.
+- Reject vague claims; demand mechanisms, constraints, and economics.
+- Produce a buildable MVP specification tied to distribution strategy.
+
+**Required evidence**
+
+- Updated venture artifacts (`THESIS`, `BLUEPRINT`, `GROWTH_LOOPS`, `MVP_SPEC`).
+- Explicit assumptions and risk register entries.
+
+## ACE-UI Task Pack
+
+- Convert product intent into clear UX flows and conversion-grade copy.
+- Run friction/trust audits and rewrite ambiguous messaging.
+- Deliver component-level string maps developers can implement directly.
+
+**Required evidence**
+
+- Updated copy deck and UX audit artifacts.
+- Developer-ready string keys and notes for implementation handoff.
+
+## ACE-Coders Task Pack
+
+- Implement from explicit spec using test-first execution.
+- Keep architecture coherent while minimizing implementation scope.
+- Produce passing checks, deployment-ready artifacts, and truthful status.
+
+**Required evidence**
+
+- Failing-to-passing test evidence.
+- Build/test output logs and updated status artifacts.
+- Residual risks or blockers listed explicitly.
+
+## ACE-Skeptic Task Pack
+
+- Convert ambiguous asks into explicit, falsifiable quality gates.
+- Challenge scope changes that are not evidence-backed.
+- Own final gate decision for readiness to proceed.
+
+**Required evidence**
+
+- Updated `QUALITY_GATES.md` with measurable pass/fail criteria.
+- `RISKS.md` updates for newly identified failure modes.
+- Explicit `GATE_DECISION` pointer in `EVIDENCE_LOG.md`.
+
+## ACE-Ops Task Pack
+
+- Maintain dependency order and blocker/circuit-breaker state.
+- Publish truthful `STATUS.md` and schema-valid handoffs.
+- Route work to the next role with bounded scope.
+- Keep scheduler flow healthy for deferred/gated work (`enqueue_job`, `dispatch_jobs`, lease ownership checks).
+
+**Required evidence**
+
+- Updated `STATUS.md` with active phase, blockers, and next action.
+- Updated `HANDOFF.json` (or SWARM handoff payload) with evidence anchors.
+- Blocker transitions captured in `EVIDENCE_LOG.md`.
+- Scheduler evidence when applicable (`agent-state/job-queue.json`, `agent-state/job-locks.json`, `agent-state/scheduler-lease.json`).
+
+## ACE-Research Task Pack
+
+- Validate hypotheses using source-backed evidence.
+- Convert unknowns into explicit assumption maps.
+- Reject unverifiable claims before spec or build proceeds.
+
+**Required evidence**
+
+- Evidence entries with concrete source pointers.
+- Assumption map and known-unknown list.
+- Confidence levels for major claims.
+
+## ACE-ASTGrep Task Pack
+
+- Produce compact structural discovery indexes using AST-first scans.
+- Keep orchestration context high-signal by avoiding oversized raw file maps.
+- Persist machine-readable and human-readable discovery artifacts with evidence anchors.
+
+**Required evidence**
+
+- Updated `AST_GREP_INDEX.md` and `AST_GREP_INDEX.json`.
+- Command references used for discovery.
+- Append-only evidence anchor in `EVIDENCE_LOG.md`.
+
+## ACE-Memory Task Pack
+
+- Reconcile evidence, decisions, and risks into compact, contradiction-free memory.
+- Remove stale or duplicate memory entries that increase routing noise.
+- Preserve source-of-truth artifacts and only summarize with explicit pointers.
+
+**Required evidence**
+
+- Updated `MEMORY_INDEX.md` with timestamped reconciliation summary.
+- Contradiction findings (if any) linked to source artifacts.
+- Evidence anchor appended to `EVIDENCE_LOG.md`.
+
+## ACE-Security Task Pack
+
+- Validate security/policy posture against active risk and verification artifacts.
+- Classify unresolved high-severity risks and owner assignments.
+- Block promotion when mitigation evidence is incomplete.
+
+**Required evidence**
+
+- Updated `SECURITY_REPORT.md`.
+- `RISKS.md` mitigation/ownership updates (or explicit residual-risk acceptance).
+- Security verdict pointer in `EVIDENCE_LOG.md`.
+
+## ACE-Observability Task Pack
+
+- Verify runbook completeness, SLO ownership, and incident routing readiness.
+- Detect operational blind spots before promotion.
+- Escalate incident-level failures with explicit ownership.
+
+**Required evidence**
+
+- Updated `OBSERVABILITY_REPORT.md`.
+- Evidence references for runbooks and routing coverage.
+- Operability verdict pointer in `EVIDENCE_LOG.md`.
+
+## ACE-Eval Task Pack
+
+- Run deterministic autonomy and regression evaluations.
+- Report suite-level scores and threshold outcomes.
+- Fail fast when regression thresholds are exceeded.
+
+**Required evidence**
+
+- Updated `EVAL_REPORT.md` with suite outputs.
+- Pass/fail threshold rationale.
+- Evaluation verdict pointer in `EVIDENCE_LOG.md`.
+
+## ACE-Release Task Pack
+
+- Issue explicit `promote/hold/rollback` decision using gate evidence.
+- Verify rollback viability and operational ownership.
+- Block promotion on unresolved upstream gate failures.
+
+**Required evidence**
+
+- Updated `RELEASE_DECISION.md`.
+- Gate-by-gate evidence references (security/eval/observability/qa).
+- Final release status pointer in `EVIDENCE_LOG.md`.
+
+## ACE-Spec Task Pack
+
+- Compile validated gates into machine-readable contracts.
+- Define interfaces, edge conditions, and requirement-to-test mappings.
+- Version and publish contract changes with compatibility notes.
+
+**Required evidence**
+
+- Updated `SPEC_CONTRACT.json`.
+- Updated `INTERFACE_DEFINITION.md` (or equivalent interface artifact).
+- Traceability mapping of requirements to tests.
+
+## ACE-Builder Task Pack
+
+- Execute red-green-refactor against the active spec contract.
+- Produce minimal implementation with provenance links.
+- Return implementation state with test evidence and residual risks.
+
+**Required evidence**
+
+- Failing and passing test outputs.
+- Changed artifact pointers with provenance/checksum where applicable.
+- Explicit residual risk list.
+
+## ACE-QA Task Pack
+
+- Run verification suites and classify each failure type.
+- Block promotion on regressions or spec violations.
+- Emit verification status with actionable remediation routing.
+
+**Required evidence**
+
+- `VERIFICATION_REPORT.md` (or equivalent) with pass/fail summary.
+- Failure classification (`spec_violation`, `bug`, `environmental`).
+- Regression check output and next-owner routing.
+
+## ACE-Docs Task Pack
+
+- Keep user/operator docs aligned with verified behavior.
+- Detect and resolve contradictions against status/scope/state artifacts.
+- Publish release-facing communication artifacts.
+
+**Required evidence**
+
+- Updated docs/changelog/runbook pointers.
+- Consistency check results against current state artifacts.
+- Any unresolved documentation risks explicitly listed.

package/assets/tasks/todo.md

@@ -0,0 +1,23 @@
+# ACE TODO Board
+
+## Active Work
+
+- [ ] Define objective and acceptance criteria in `agent-state/TASK.md`
+- [ ] Confirm scope boundaries in `agent-state/SCOPE.md`
+- [ ] Route to the correct capability module
+- [ ] Produce artifact changes
+- [ ] Verify with objective evidence (tests, logs, checks)
+
+## Verification Checklist
+
+- [ ] Requested artifact(s) created or updated
+- [ ] Validation output recorded
+- [ ] Risks and decisions logged
+- [ ] Handoff status explicit (done/blocked/next)
+
+## Review Notes
+
+- Date: `YYYY-MM-DD`
+- What changed: 
+- Evidence pointers: 
+- Residual risks: 

package/dist/ace-autonomy.d.ts

@@ -0,0 +1,137 @@
+export declare const ACE_TASK_CONTRACT_FILES: readonly ["agent-state/TASK.md", "agent-state/SCOPE.md", "agent-state/QUALITY_GATES.md", "agent-state/HANDOFF.json"];
+export declare const ACE_DEFAULT_STATE_SOURCES: readonly ["agent-state/TASK.md", "agent-state/SCOPE.md", "agent-state/QUALITY_GATES.md", "agent-state/STATUS.md", "agent-state/HANDOFF.json", "agent-state/EVIDENCE_LOG.md"];
+export declare const ACE_DEFAULT_CONTINUITY_SOURCES: readonly ["agent-state/TASK.md", "agent-state/SCOPE.md", "agent-state/QUALITY_GATES.md", "agent-state/HANDOFF.json", "agent-state/STATUS.md", "agent-state/DECISIONS.md", "agent-state/RISKS.md", "agent-state/EVIDENCE_LOG.md"];
+export interface AutonomyPolicyConfig {
+    orchestrator_preflight?: boolean | null;
+    recall_context?: boolean | null;
+    state_sources?: string[] | null;
+    before_run_checks?: string[] | null;
+    stop_checks?: string[] | null;
+    review_mode?: string | null;
+}
+export interface NormalizedAutonomyPolicy {
+    orchestrator_preflight: boolean;
+    recall_context: boolean;
+    state_sources: string[];
+    before_run_checks: string[];
+    stop_checks: string[];
+    review_mode: string | null;
+}
+export interface ContinuityPolicyConfig {
+    enabled?: boolean | null;
+    source_paths?: string[] | null;
+    max_sources?: number | null;
+    max_excerpt_chars?: number | null;
+    max_total_chars?: number | null;
+    max_status_events?: number | null;
+    max_run_ledger_entries?: number | null;
+    include_snapshot?: boolean | null;
+}
+export interface NormalizedContinuityPolicy {
+    enabled: boolean;
+    source_paths: string[];
+    max_sources: number;
+    max_excerpt_chars: number;
+    max_total_chars: number;
+    max_status_events: number;
+    max_run_ledger_entries: number;
+    include_snapshot: boolean;
+}
+export interface AceFileStatus {
+    path: string;
+    present: boolean;
+    valid: boolean;
+    note: string;
+}
+export interface AceTaskContractAssessment {
+    ok: boolean;
+    summary: string;
+    missing: string[];
+    invalid: string[];
+    blockers: string[];
+    files: AceFileStatus[];
+    handoff_status?: string;
+    handoff_reason?: string;
+}
+export interface AceStateSlice {
+    path: string;
+    present: boolean;
+    excerpt: string;
+}
+export interface AceContextSnapshot {
+    name: string;
+    timestamp: string;
+    summary: string;
+    path: string;
+    content: string;
+}
+export interface AceRecallContext {
+    task_contract: AceTaskContractAssessment;
+    state_slices: AceStateSlice[];
+    snapshot?: AceContextSnapshot;
+}
+export interface AceContinuityPacketSource {
+    path: string;
+    excerpt: string;
+    chars: number;
+}
+export interface AceContinuityPacketEvent {
+    timestamp: string;
+    source_module: string;
+    event_type: string;
+    status: string;
+    summary: string;
+}
+export interface AceContinuityPacketRunEntry {
+    timestamp: string;
+    tool: string;
+    category: string;
+    message: string;
+    artifacts: string[];
+}
+export interface AceContinuityPacket {
+    generated_at: string;
+    summary: string;
+    highlights: string[];
+    task_contract_ok: boolean;
+    blockers: string[];
+    included_sources: AceContinuityPacketSource[];
+    missing_sources: string[];
+    dropped_sources: string[];
+    recent_status_events: AceContinuityPacketEvent[];
+    recent_run_ledger: AceContinuityPacketRunEntry[];
+    snapshot?: {
+        name: string;
+        timestamp: string;
+        summary: string;
+        path: string;
+    };
+    budget_report: {
+        max_sources: number;
+        max_excerpt_chars: number;
+        max_total_chars: number;
+        max_status_events: number;
+        max_run_ledger_entries: number;
+        used_chars: number;
+    };
+}
+export declare const DEFAULT_AUTONOMY_POLICY: NormalizedAutonomyPolicy;
+export declare const DEFAULT_CONTINUITY_POLICY: NormalizedContinuityPolicy;
+export declare function normalizeAutonomyPolicy(input?: AutonomyPolicyConfig | null): NormalizedAutonomyPolicy;
+export declare function normalizeContinuityPolicy(input?: ContinuityPolicyConfig | null): NormalizedContinuityPolicy;
+export declare function readAceTaskContractAssessment(): AceTaskContractAssessment;
+export declare function readAceContextSnapshot(name?: string): AceContextSnapshot | undefined;
+export declare function buildAceRecallContext(input?: {
+    state_sources?: readonly string[];
+    snapshot_name?: string;
+    excerpt_chars?: number;
+}): AceRecallContext;
+export declare function buildAceContinuityPacket(input?: {
+    state_sources?: readonly string[];
+    snapshot_name?: string;
+    policy?: ContinuityPolicyConfig | NormalizedContinuityPolicy | null;
+}): AceContinuityPacket;
+export declare function formatAceRecallMarkdown(recall: AceRecallContext): string;
+export declare function formatAceContinuityPacketMarkdown(packet: AceContinuityPacket): string;
+export declare function buildAutonomyHookEnv(policy: NormalizedAutonomyPolicy, continuity?: NormalizedContinuityPolicy): Record<string, string>;
+//# sourceMappingURL=ace-autonomy.d.ts.map