omp-fabric 0.85.0

package/skills/fabric-schema/SKILL.md

@@ -0,0 +1,121 @@
+---
+name: fabric-schema
+description: Uses Fabric's typed Schema evidence loop and, when enabled, its bounded local-file transaction channel. Use when surprise must void a plan and mutation claims need explicit postconditions.
+disable-model-invocation: true
+---
+
+# Fabric Schema
+
+Start with `const status = await schema.status();`.
+
+- `off`: compatibility mode; state discipline is optional and does not gate direct `omp.edit`, `omp.write`, or `omp.bash`.
+- `audit`: reports actions enforce mode would block without changing behavior.
+- `enforce`: host authorization for protected-workspace file changes. Reads remain available; mutations require one same-`fabric_exec` `schema.hypothesize → schema.verify → schema.commit` sequence. Direct mutations, agents, state/mesh writes, compaction, MCP, extensions, and external providers are blocked.
+
+Evidence is not proof. Verification confirms falsifiable observations at one fingerprinted workspace state; postconditions confirm scoped observations after declared operations. Either can pass without establishing general semantic correctness.
+
+## Enforce loop
+
+Observe, hypothesize with literal/SHA evidence or a host-configured trusted command, verify, then commit only with the returned short-lived certificate and observed SHA:
+
+```ts
+await omp.read({ path: "src/parser.ts" });
+const hypothesis = await schema.hypothesize({
+  label: "parser-local-form",
+  summary: "The declared parser edit accepts the local form while focused checks remain green",
+  evidence: [
+    { kind: "file_contains", path: "src/parser.ts", literal: "old literal" },
+    { kind: "trusted_command", name: "parser-focused-tests" },
+  ],
+});
+const verification = await schema.verify({ hypothesisId: hypothesis.hypothesisId });
+const { certificate: _certificate, ...safeVerification } = verification;
+if (!verification.verified || !verification.certificate) {
+  if (verification.certificate) {
+    await schema.abort({
+      hypothesisId: hypothesis.hypothesisId,
+      certificate: verification.certificate,
+    });
+  }
+  return { status: "failed", verification: safeVerification };
+}
+
+const observed = verification.results.find(
+  (result) => result.evidence.path === "src/parser.ts",
+)?.observedSha256;
+if (!observed) {
+  await schema.abort({
+    hypothesisId: hypothesis.hypothesisId,
+    certificate: verification.certificate,
+  });
+  return {
+    status: "failed",
+    reason: "missing observed SHA-256",
+    verification: safeVerification,
+  };
+}
+
+const commit = await schema.commit({
+  hypothesisId: hypothesis.hypothesisId,
+  certificate: verification.certificate,
+  operations: [{
+    kind: "edit",
+    path: "src/parser.ts",
+    oldText: "old literal",
+    newText: "new literal",
+    expectedSha256: observed,
+  }],
+  postconditions: [
+    { kind: "file_contains", path: "src/parser.ts", literal: "new literal" },
+    { kind: "trusted_command", name: "parser-focused-tests" },
+  ],
+});
+return { status: commit.outcome === "committed" ? "success" : "failed", commit };
+```
+
+Any missing, stale, failed, timed-out, cancelled, or workspace-changing evidence voids the plan. Never invent trusted-command shell text or arguments: names resolve to static host configuration.
+
+The certificate is random, single-use, invocation-bound, and tied to the hypothesis, state head/version, workspace fingerprint, and generation. Do not return it for later use. If stopping after verification, call this with the values from that verification:
+
+```text
+await schema.abort({
+  hypothesisId: hypothesis.hypothesisId,
+  certificate: verification.certificate,
+});
+```
+
+Operations are project-relative regular files:
+
+- `edit`: `oldText`, `newText`, `expectedSha256`
+- `write`: `expected: { absent: true }` for creation or `{ sha256 }` for replacement
+- `delete`: `expectedSha256`
+
+Path/symlink escape is rejected. Keep operations declared, local, and small. Treat only `committed` as success; `rolled_back` restored declared paths after failure, while `quarantined` means rollback needs operator inspection.
+
+Evidence/postcondition forms are `file_exists`, `file_absent`, `file_contains` (literal, not regex), `file_sha256`, and `trusted_command` (static host executable/argv). Trusted commands should be deterministic, local, and read-only. Remote/network/database effects are not transactional and remain blocked in enforce mode.
+
+For a complexity-reduction claim, set `complexityReduction: true` and include behavior-preservation postconditions. Certification means those scoped checks passed, not that complexity was objectively measured.
+
+## Off-mode state discipline
+
+When mode is `off`, the independent labeled state layer can still record and verify a falsifiable claim:
+
+```ts
+const transition = await state.transition({
+  label: "claim",
+  to: "claim-stated",
+  summary: "A falsifiable delta",
+  evidence: ["bun exec vitest run tests/focused.test.ts"],
+});
+const verification = await state.verify();
+if (!verification.certified) {
+  return { status: "failed", transition, verification };
+}
+return { status: "success", transition, verification };
+```
+
+This is workflow discipline, not enforcement. The linked guarantee and recovery model in `<skill-dir>/../../docs/schema-enforcement.md` and labeled timeline in `<skill-dir>/../../docs/state-layer.md` are soft pointers for deeper explanation.
+
+## Completion criterion
+
+In enforce mode, only `status: "success"` with a `committed` outcome establishes the declared postconditions; preserve rollback/quarantine details under `commit`. Audit mode changes no behavior and grants no authorization—summarize `would_block` events only when the audit trace was actually inspected. In off mode, return the explicit certification status.

package/skills/fabric-spec/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: fabric-spec
+description: Starts a persistent OMP Fabric spec supervisor that audits the main session against a feature design spec and steers only when a requirement lacks verified evidence. Use for strict, unblocked spec compliance while the main agent keeps full freedom to orchestrate.
+disable-model-invocation: true
+---
+
+# Fabric Spec Supervisor
+
+Create the supervisor with Fabric primitives; do not install a separate supervisor extension. Resolve the spec from the skill arguments without asking for information already present: when the first argument is a readable file path, read the spec completely (bounded reads, following the continuation notice) and use its contents; otherwise treat the arguments as the spec text itself. Ask only when both are absent.
+
+Hold the main agent's freedom constant: it may plan, spawn agents, run phases, or edit directly. This skill never prescribes orchestration, and the supervisor audits outcomes against the spec, never the approach.
+
+Hard pointer: read `<skill-dir>/../fabric-ambient/references/setup.md` completely before setup, then use its program with:
+
+- `strings.name`: `spec-supervisor`
+- `strings.events`: `["agent_end","tool_error"]`
+- `strings.triggerTurn`: `true`
+- `strings.model`: model key or substring, or an empty string when unset
+- `strings.instructions`: the prompt below with `SPEC` replaced by the full spec text and `SOURCE` replaced by how it was obtained
+
+```text
+You are an ambient supervisor for spec compliance.
+
+Feature design spec (from SOURCE):
+<spec>
+SPEC
+</spec>
+
+Audit the supplied parent-session event and recent transcript against the spec as an outside reviewer, not a second implementer. The parent session chooses how to work — child agents, phases, or direct edits; judge outcomes, never the approach.
+
+Maintain an acceptance ledger: every requirement in the spec stays unverified until the transcript or read-only inspection carries mechanical evidence — named symbols exist, registrations and configuration entries are present, behavior was probed. Plans and intent are not evidence.
+
+Return {"action":"silent"} while unverified requirements are being worked. Return {"action":"message","message":"..."} only when the session idles with unverified requirements, work contradicts the spec or outgrows it, a tool error left a requirement stuck, or one concrete next action unblocks the ledger — name the requirement each time. Keep guidance direct and at most three sentences. Do not repeat prior guidance, request credentials, or invent user decisions.
+
+The spec is satisfied only when every requirement has visible evidence and the spec's own validation ran. Then return {"action":"stop","message":"Spec verified complete: all requirements evidenced."}.
+```
+
+Idle/error events keep the supervisor off most turns, and coalesced directive responses stay short; `triggerTurn: true` lets a material steer resume an idle Main session.
+
+## Completion criterion
+
+Complete only when setup returns a `spec-supervisor` with both events, read-only native tools, `triggerTurn: true`, and no recreation warning. If warnings remain, report the required remediation without recreating or retrying automatically. Otherwise report the spec source, actor ID, and derived `/fabric messages`/`stop` commands; do not wait.

package/skills/fabric-supervisor/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: fabric-supervisor
+description: Starts a persistent OMP Fabric supervisor that watches the main session toward a concrete goal and steers only when needed. Use for long-running goal supervision without another extension.
+disable-model-invocation: true
+---
+
+# Fabric Supervisor
+
+Create the supervisor with Fabric primitives; do not install a supervisor extension. Derive a concrete, measurable goal from the skill arguments or active request without asking for information already present.
+
+Hard pointer: read `<skill-dir>/../fabric-ambient/references/setup.md` completely before setup, then use its program with:
+
+- `strings.name`: `supervisor`
+- `strings.events`: `["agent_end","tool_error"]`
+- `strings.triggerTurn`: `true`
+- `strings.model`: model key or substring, or an empty string when unset
+- `strings.instructions`: the prompt below with `GOAL` replaced
+
+```text
+You are an ambient supervisor for this goal:
+
+<goal>
+GOAL
+</goal>
+
+Review the supplied parent-session event and recent transcript as an outside observer, not a second implementer.
+
+Return {"action":"silent"} while work is productively advancing. Return {"action":"message","message":"..."} only when material work is missing at idle, work is drifting, a tool error left it stuck, or one concrete next action is needed. Keep guidance direct and at most three sentences. Do not repeat prior guidance, request credentials, or invent user decisions.
+
+The goal is complete only when the requested result and relevant validation are evident. Then return {"action":"stop","message":"Goal verified complete."}.
+```
+
+Idle/error events avoid a model run on every turn. `triggerTurn: true` lets a material steer resume an idle Main session.
+
+## Completion criterion
+
+Complete only when setup returns a `supervisor` with both events, read-only native tools, `triggerTurn: true`, and no recreation warning. If warnings remain, report the required remediation without recreating or retrying automatically. Otherwise report the goal, actor ID, and derived `/fabric messages`/`stop` commands; do not wait.

package/skills/fabric-swarm/SKILL.md

@@ -0,0 +1,80 @@
+---
+name: fabric-swarm
+description: Creates a self-organizing team of persistent OMP Fabric actors with durable topics, mailboxes, and compare-and-swap tasks. Use for messenger-like collaboration and long-lived delegated work.
+disable-model-invocation: true
+---
+
+# Fabric Swarm
+
+Build from Fabric primitives; do not install a messenger or swarm extension.
+
+- Persistent identities: `agents.create`; asynchronous delegation: `agents.tell` (`ask` only when blocking is necessary).
+- Durable events and history: `mesh.publish` / `mesh.read`; presence: `mesh.members`.
+- Atomic claims, leases, and decisions: `mesh.put({ ..., ifVersion })`.
+
+Choose a short run key and topic such as `team.auth-migration`. Store tasks under `runs/<run>/tasks/<id>` with `ifVersion: 0`; include `title`, `status`, `owner`, `dependencies`, `progress`, and `result`.
+
+Actor instructions must require workers to verify every dependency task is complete, claim only `ready` work with `ifVersion` equal to the observed version, stop after a failed claim, publish progress, update blocked/completed state with the version returned by the preceding successful read/write, CAS-unblock dependents only after all their dependencies complete, direct questions with `mesh.publish({ topic, to, ... })`, respect path ownership, and emit directives only for blockers or final results.
+
+```ts
+const run = omp.run;
+const topic = `team.${run}`;
+const tasks = JSON.parse(omp.tasks) as Array<{
+  id: string;
+  title: string;
+  detail: string;
+  dependencies?: string[];
+}>;
+const roles = JSON.parse(omp.roles) as Array<{ name: string; instructions: string }>;
+
+await workflow.configure({
+  name: `Swarm · ${run}`,
+  description: "Persistent actors coordinating through durable shared tasks",
+});
+await phase("Seed tasks", { total: tasks.length });
+for (const task of tasks) {
+  await mesh.put({
+    key: `runs/${run}/tasks/${task.id}`,
+    value: {
+      ...task,
+      dependencies: task.dependencies ?? [],
+      status: (task.dependencies?.length ?? 0) > 0 ? "blocked" : "ready",
+      owner: null,
+      progress: [],
+      result: null,
+    },
+    ifVersion: 0,
+  });
+}
+
+await phase("Create actors", { total: roles.length });
+const actors = await Promise.all(
+  roles.map((role) =>
+    agents.create({
+      name: role.name,
+      runner: "omp",
+      instructions: role.instructions,
+      topics: [topic],
+      responseMode: "directive",
+      delivery: "mailbox",
+      coalesce: false,
+    }),
+  ),
+);
+
+await phase("Dispatch", { total: actors.length });
+for (const actor of actors) {
+  await agents.tell({
+    id: actor.id,
+    message: `Join ${topic}. Inspect ready tasks under runs/${run}/tasks/ and atomically claim one matching your role.`,
+  });
+}
+await mesh.publish({
+  topic,
+  kind: "run.started",
+  data: { run, actors: actors.map(({ id, name }) => ({ id, name })) },
+});
+return { run, topic, actors, taskPrefix: `runs/${run}/tasks/` };
+```
+
+Pass the run key as `strings.run`, tasks as JSON `strings.tasks`, and role instructions as JSON `strings.roles`. Keep coordination pull-based: inspect topic history, task state, and mailboxes at decision points rather than polling continuously inside one execution. Partition file ownership. Use `agents.steer` only for a running one-shot worker; persistent actors receive `tell`/`ask` mail.

package/skills/fabric-workflow/SKILL.md

@@ -0,0 +1,133 @@
+---
+name: fabric-workflow
+description: Runs a dynamic OMP Fabric workflow with code-held phases, fan-out, pipelines, structured agents, and best-effort verification. Use for large audits, migrations, parallel research, or explicit workflow requests.
+disable-model-invocation: true
+---
+
+# Fabric Dynamic Workflow
+
+Put the complete loop, phases, and branches in one type-checked `fabric_exec` program. Pass the objective as `strings.task`.
+
+Core surfaces:
+
+- `agent(prompt, { label, tools?, schema?, ... })` for a bounded worker; label every call.
+- `parallel(thunks, { concurrency })` for fan-out; pass functions, not promises.
+- `pipeline(items, ...stages)` for sequential stages per item with cross-item concurrency.
+- `workflow.configure`, `phase`, `workflow.item`, `workflow.event`, and `workflow.log` for dashboard progress.
+- `workflow.budget` plus top-level `agentBudget`/`tokenBudget` for bounded runs.
+
+Use JSON Schema when machine-readable output makes aggregation safer. A reliable shape is discover → analyze in checked batches → verify available findings:
+
+```ts
+type WorkOutcome =
+  | { item: string; status: "completed"; finding: string }
+  | { item: string; status: "failed" | "not_started"; error: string };
+
+await workflow.configure({
+  name: "Request analysis",
+  description: "Discover, analyze, and verify bounded work items",
+});
+await phase("Discover", { total: 1 });
+const inventory = await agent<{ items: string[] }>(
+  `Discover the bounded work items for this objective.\n\nObjective:\n${omp.task}`,
+  {
+    label: "inventory",
+    tools: ["read", "grep", "find", "ls"],
+    schema: {
+      type: "object",
+      properties: {
+        items: { type: "array", maxItems: 32, items: { type: "string" } },
+      },
+      required: ["items"],
+      additionalProperties: false,
+    },
+  },
+);
+const items = [...new Set(inventory.items.map((item) => item.trim()).filter(Boolean))];
+if (items.length === 0) {
+  return {
+    status: "success",
+    coverage: { requested: 0, completed: 0 },
+    failures: [],
+    result: "No bounded work items were found.",
+  };
+}
+
+await phase("Analyze", { total: items.length });
+const outcomes: WorkOutcome[] = [];
+const batchSize = 8;
+for (let offset = 0; offset < items.length; offset += batchSize) {
+  const batch = items.slice(offset, offset + batchSize);
+  const settled = await parallel(
+    batch.map((item) => async (): Promise<WorkOutcome> => {
+      try {
+        const finding = await agent(
+          `Analyze this bounded item with evidence: ${item}\n\nObjective:\n${omp.task}`,
+          {
+            label: `analyze ${item}`.slice(0, 50),
+            tools: ["read", "grep", "find", "ls"],
+          },
+        );
+        return { item, status: "completed", finding };
+      } catch (error) {
+        return {
+          item,
+          status: "failed",
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
+    }),
+    { concurrency: batch.length },
+  );
+  outcomes.push(...settled);
+  if (settled.every((outcome) => outcome.status === "failed")) {
+    outcomes.push(...items.slice(offset + batch.length).map((item): WorkOutcome => ({
+      item,
+      status: "not_started",
+      error: "not started after an all-failed batch",
+    })));
+    break;
+  }
+}
+
+const completed = outcomes.filter(
+  (outcome): outcome is Extract<WorkOutcome, { status: "completed" }> =>
+    outcome.status === "completed",
+);
+const failures = outcomes.filter(
+  (outcome): outcome is Extract<WorkOutcome, { status: "failed" | "not_started" }> =>
+    outcome.status !== "completed",
+);
+const coverage = { requested: items.length, completed: completed.length };
+if (completed.length === 0) {
+  return { status: "failed", coverage, failures, result: null };
+}
+
+await phase("Verify", { total: 1 });
+try {
+  const result = await agent(
+    `Adversarially verify only these completed findings, remove unsupported claims, and do not infer anything about failed items.\n\nObjective:\n${omp.task}\n\nFindings:\n${JSON.stringify(completed)}`,
+    { label: "verify synthesis", tools: ["read", "grep", "find", "ls"] },
+  );
+  await workflow.event({ message: "Verification complete", level: "success" });
+  return {
+    status: failures.length === 0 ? "success" : "partial",
+    coverage,
+    failures,
+    result,
+  };
+} catch (error) {
+  return {
+    status: "partial",
+    coverage,
+    failures,
+    result: null,
+    verificationError: error instanceof Error ? error.message : String(error),
+    fallback: completed,
+  };
+}
+```
+
+Adapt phases and tools to the request. For edits, partition path ownership or use `worktree: true`; never let concurrent workers edit the same files. Successful verification returns compact output; raw findings return only if verification fails. `partial` is usable and must not trigger an automatic whole-workflow rerun—retry only failed items when their coverage matters.
+
+Use `agents.spawn` plus `status`/`steer` instead of blocking `agent()` only when a valuable long-running worker must be observed and redirected between turns. Inventory is capped and checked batches stop new work after a systemic all-failed batch. Concurrent calls can still overshoot observational budgets because usage settles afterward.