@irisrun/bundle-coding 0.1.0

package/dist/coding.d.ts

@@ -0,0 +1,38 @@
+import type { Bundle, Tactic } from "@irisrun/core";
+/** The stable id pinned into `Lock.tactics.bundle` and journaled as the tacticId. */
+export declare const BUNDLE_ID = "iris/coding";
+export interface CodingBundleOptions {
+    /** Extra read-only tools to allow-list (merged with the coding defaults). */
+    readOnlyTools?: string[];
+    /** shouldCompact trailing-window size (passed to windowCompaction). */
+    keepLast?: number;
+    /** onToolError retry cap (passed to toolRepair). */
+    maxAttempts?: number;
+    invariants?: {
+        maxStepsPerTurn?: number;
+        maxToolCalls?: number;
+    };
+}
+/**
+ * The coding-specialized gateAction tactic: read-only / codebase-search tools are
+ * a safe ALLOW; every other tool — writes (`write_file`), shell (`run_shell`),
+ * and anything unknown/irreversible — is gated to "ask" (HITL). A host-side
+ * factory function (not a bare object), matching core's convention.
+ */
+export declare function codingGate(readOnlyTools?: string[]): Tactic<"gateAction">;
+/**
+ * The coding bundle's decideNext: it DELEGATES verbatim to the proven ReAct
+ * tool-loop (continue while the model still requests tools, finish when it stops) —
+ * which is the CORRECT policy for a coding tool-loop agent, so there is nothing to
+ * "tune" today. The coding-specific behavior lives in `codingGate` (the
+ * read-only-allow / write-gate split). This is kept as a DISTINCT factory only so a
+ * future coding heuristic (e.g. a max-edit budget) can layer in here without
+ * touching core or the bundle's call sites — it is a pass-through for now.
+ */
+export declare function codingDecideNext(): Tactic<"decideNext">;
+/**
+ * Assemble the coding bundle: the SAME structure as core's `defaultBundle`, with
+ * the coding-specialized gate + decideNext and the reused window-compaction /
+ * tool-repair tactics, returning `{ tacticPerformer, invariants }`.
+ */
+export declare function codingBundle(opts?: CodingBundleOptions): Bundle;

package/dist/coding.js

@@ -0,0 +1,101 @@
+// @irisrun/bundle-coding — the first domain (coding) tactic bundle. HOST-SIDE: it
+// composes coding-specialized tactics on the 5 harness seams from @irisrun/core's
+// EXPORTED primitives ([[lrn-core-exports-functions-only]]), so @irisrun/core stays
+// byte-untouched. The assembled `codingBundle()` returns the SAME shape as core's
+// `defaultBundle()` — a pure `tacticPerformer` (a Performer answering a
+// {seam, payload} request with {seam, tacticId:"iris/coding", choice}) plus the
+// kernel invariant caps. The journaled {seam, tacticId, choice} outcome rides the
+// `tactic` effect's result value exactly like the default bundle, so the ADR-0007
+// quarantine (replay folds the journaled choice, never re-invokes a tactic)
+// applies to this external bundle unchanged.
+//
+// Pure composition over core's surface — no host/Node imports (the @irisrun/core
+// dependency is the ONLY dependency; this package is NOT a host/transport package).
+import { composeAssemble, composeDecideNext, composeGate, reactAssembleContext, reactDecideNext, windowCompaction, toolRepair, defaultInvariants, } from "@irisrun/core";
+/** The stable id pinned into `Lock.tactics.bundle` and journaled as the tacticId. */
+export const BUNDLE_ID = "iris/coding";
+// The read-only / reversible tools a coding agent may run without a gate. Writes
+// and shell are NOT here — they default to "ask" (HITL approval), the secure
+// gate-irreversible-by-default floor for a coding workflow.
+const DEFAULT_READ_ONLY_TOOLS = ["read_file", "search", "list", "grep", "glob"];
+/**
+ * The coding-specialized gateAction tactic: read-only / codebase-search tools are
+ * a safe ALLOW; every other tool — writes (`write_file`), shell (`run_shell`),
+ * and anything unknown/irreversible — is gated to "ask" (HITL). A host-side
+ * factory function (not a bare object), matching core's convention.
+ */
+export function codingGate(readOnlyTools = []) {
+    const safe = new Set([...DEFAULT_READ_ONLY_TOOLS, ...readOnlyTools]);
+    return {
+        id: "iris/coding-gate",
+        seam: "gateAction",
+        decide: ({ call }) => (safe.has(call.name) ? "allow" : "ask"),
+    };
+}
+/**
+ * The coding bundle's decideNext: it DELEGATES verbatim to the proven ReAct
+ * tool-loop (continue while the model still requests tools, finish when it stops) —
+ * which is the CORRECT policy for a coding tool-loop agent, so there is nothing to
+ * "tune" today. The coding-specific behavior lives in `codingGate` (the
+ * read-only-allow / write-gate split). This is kept as a DISTINCT factory only so a
+ * future coding heuristic (e.g. a max-edit budget) can layer in here without
+ * touching core or the bundle's call sites — it is a pass-through for now.
+ */
+export function codingDecideNext() {
+    const react = reactDecideNext();
+    return {
+        id: "iris/coding-decide",
+        seam: "decideNext",
+        decide: ({ state }) => react.decide({ state }),
+    };
+}
+/**
+ * Assemble the coding bundle: the SAME structure as core's `defaultBundle`, with
+ * the coding-specialized gate + decideNext and the reused window-compaction /
+ * tool-repair tactics, returning `{ tacticPerformer, invariants }`.
+ */
+export function codingBundle(opts = {}) {
+    const assembleChain = [reactAssembleContext()];
+    const decideChain = [codingDecideNext()];
+    const gateChain = [codingGate(opts.readOnlyTools)];
+    const compact = windowCompaction(opts.keepLast);
+    const repair = toolRepair(opts.maxAttempts);
+    const tacticPerformer = async (request) => {
+        const req = request;
+        const seam = req.seam ?? "";
+        const payload = req.payload ?? null;
+        let choice;
+        switch (seam) {
+            case "assembleContext": {
+                const pl = payload;
+                choice = composeAssemble(assembleChain, pl.state, pl.ctx);
+                break;
+            }
+            case "shouldCompact": {
+                const pl = payload;
+                choice = compact.decide(pl);
+                break;
+            }
+            case "gateAction": {
+                const pl = payload;
+                choice = composeGate(gateChain, pl.call);
+                break;
+            }
+            case "onToolError": {
+                const pl = payload;
+                choice = repair.decide(pl);
+                break;
+            }
+            case "decideNext": {
+                const pl = payload;
+                choice = composeDecideNext(decideChain, pl.state);
+                break;
+            }
+            default:
+                return { ok: false, error: { message: `codingBundle: unknown seam '${seam}'` } };
+        }
+        return { ok: true, value: { seam, tacticId: BUNDLE_ID, choice } };
+    };
+    const invariants = defaultInvariants(opts.invariants);
+    return { tacticPerformer, invariants };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export declare const PACKAGE = "@irisrun/bundle-coding";
+export { codingBundle, codingGate, codingDecideNext, BUNDLE_ID, } from "./coding.js";
+export type { CodingBundleOptions } from "./coding.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+// @irisrun/bundle-coding — public surface (host-side; composes from @irisrun/core's
+// exported tactic primitives only — @irisrun/core is the ONLY dependency, and this
+// is NOT a host/transport package).
+export const PACKAGE = "@irisrun/bundle-coding";
+export { codingBundle, codingGate, codingDecideNext, BUNDLE_ID, } from "./coding.js";

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@irisrun/bundle-coding",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Iris first domain tactic bundle — coding-specialized seam tactics (read-only tools allow / writes+shell gated to ask, a tool-loop decideNext, window-compaction + tool-repair) composed HOST-SIDE from @irisrun/core's exported primitives. Produces the defaultBundle shape {tacticPerformer, invariants}; journaled {seam, tacticId, choice} outcomes inherit the ADR-0007 replay quarantine. @irisrun/core dependency only; core stays byte-untouched.",
+  "exports": {
+    ".": {
+      "iris-src": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@irisrun/core": "^0.1.0"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xoai/iris.git",
+    "directory": "packages/bundle-coding"
+  },
+  "homepage": "https://github.com/xoai/iris#readme",
+  "files": [
+    "dist"
+  ]
+}