@jigging/jig 0.1.0-alpha.10 → 0.1.0-alpha.11

package/README.md

@@ -33,14 +33,24 @@ independently validated; Jig fails closed when a required capability is absent.
 The alpha requires:
 
 - Linux x86_64 with glibc 2.17 or newer and an SSE4.2-capable baseline CPU;
-- Bubblewrap 0.12 or newer at `/usr/bin/bwrap`;
-- GNU `readlink -f` at `/usr/bin/readlink` or `/bin/readlink`;
+- Bubblewrap 0.12 or newer and GNU `readlink -f`, located as described below;
 - cgroup v2 with delegated `cpu`, `memory`, and `pids` controllers;
 - a systemd user manager with transient delegated scopes; and
 - unprivileged user, mount, PID, network, IPC, UTS, and cgroup namespaces.
 
 The glibc and SSE4.2 floors come from the selected Bun baseline runtime.
 
+Host tools are resolved through `/usr/bin`, `/bin`, or the NixOS system profile
+`/run/current-system/sw/bin`, never ambient `PATH`. An operator may select
+Bubblewrap using an absolute `JIG_BWRAP_PATH`, including a shell-local Nix
+dependency. It receives the same validation and never falls back on failure.
+On NixOS, enable
+`programs.nix-ld.enable` for the unmodified npm runtime. Jig uses the real glibc
+loader at the system-managed `share/nix-ld/lib/ld.so` link, mounting only that
+loader and its required libraries into Runs. It does not mount nix-ld or the
+whole Nix store. NixOS path support is included in this source candidate;
+independent NixOS host conformance is not yet established.
+
 Jig commands do not use `sudo`, download runtimes, or expose host control to
 Flow code. Runtime installation is handled once by npm with the Jig package.
 
@@ -136,7 +146,7 @@ import { defineBinding } from "@jigging/jig";
 
 export default defineBinding({
   package: "./flows/reviewer",
-  slots: { research: "./flows/research" },
+  slots: { research: "flow:flows/research" },
 });
 ```
 
@@ -145,21 +155,24 @@ jig run binding:reviewer --input '{}'
 ```
 
 `slots` is optional and omission normalizes to `{}`. It maps at most 256
-LocalName keys to other selected, direct-eligible Flow package paths in the
-same admitted generation. Slots belong to the Binding; a direct `flow:` Run
-has none.
+LocalName keys to explicit `flow:<path>` or `binding:<id>` targets in the same
+admitted generation. Slots belong to the Binding; a direct `flow:` Run has none.
+Selected child Bindings must have no child slots of their own.
 
 Each `flow/call` carries JSON/1 input into a fresh child context and returns a
-complete JSON/1 Run result. The child receives empty settings and attachments,
-no inherited slots, and a deadline no later than its parent. Run/1 controls
+complete JSON/1 Run result. The child receives its selected target's admitted
+settings and Agent capability, empty attachments, no inherited slots, and a
+deadline no later than its parent. It selects its own package-local Skills per
+Agent call; providers and credentials remain host choices. Run/1 controls
 operation identity, duplicate joins, conflicting reuse, cancellation, and
 uncertainty; Jig does not replay uncertain dispatch automatically. There is no
 separate child history, administration, scheduler, catalogue, or resolver. Jig
 also never guesses an unprefixed target.
 
-The alpha admits one active child operation per parent; excess distinct
-concurrent calls receive `RESOURCE_EXHAUSTED`, while sequential calls remain
-available.
+Each Run context admits one active operation; a child Flow can own one Agent
+operation while its parent awaits it. Excess distinct concurrent calls receive
+`RESOURCE_EXHAUSTED`, while sequential calls remain available. Cancellation and
+cleanup cover the specialist and its locally owned Agent worker.
 
 One experimental [Agent Run capability](https://jig.md/spec/agent-run) is
 available through ordinary Run/1 `effect/call`. The host may use the official

package/bin/jig

@@ -16,6 +16,8 @@ if [ -x /usr/bin/readlink ]; then
   readlink=/usr/bin/readlink
 elif [ -x /bin/readlink ]; then
   readlink=/bin/readlink
+elif [ -x /run/current-system/sw/bin/readlink ]; then
+  readlink=/run/current-system/sw/bin/readlink
 else
   fail
 fi

package/dist/index.js

@@ -1783,6 +1783,12 @@ function normalizeJig(input, canonical) {
 function defineBinding(input) {
   return normalizeBinding(input, false);
 }
+function flowRef(path) {
+  return record({ kind: "flow", path: normalizeProjectPath(path, "Flow reference") });
+}
+function bindingRef(id) {
+  return record({ kind: "binding", id: validateLocalName(id, "Binding reference") });
+}
 function normalizeBinding(input, canonical) {
   const captured = snapshotJsonObject(input, "Binding definition");
   assertClosedObject(captured, canonical ? ["kind", "package", "settings", "slots"] : ["package", "settings", "slots"], "Binding definition");
@@ -1804,10 +1810,20 @@ function normalizeFlowSlots(value) {
   const output = Object.create(null);
   for (const name of Object.keys(input).sort(compareUtf8)) {
     validateLocalName(name, "slot name");
-    output[name] = normalizeProjectPath(input[name], `slot ${name}`);
+    const target = parseRunTargetSelector(input[name], `slot ${name}`);
+    output[name] = target.kind === "flow" ? `flow:${target.path}` : `binding:${target.id}`;
   }
   return Object.freeze(output);
 }
+function parseRunTargetSelector(value, label) {
+  if (typeof value !== "string")
+    throw new TypeError(`${label} must be a target selector`);
+  if (value.startsWith("flow:"))
+    return flowRef(normalizeProjectPath(value.slice(5), label));
+  if (value.startsWith("binding:"))
+    return bindingRef(validateLocalName(value.slice(8), label));
+  throw new TypeError(`${label} must select flow:<path> or binding:<id>`);
+}
 function normalizeSource(value, field, canonical) {
   if (value === undefined)
     throw new TypeError(`${field} cannot be undefined`);

package/dist/project/author.d.ts

@@ -47,3 +47,5 @@ export declare function flowRef(path: string): FlowRef;
 export declare function bindingRef(id: string): BindingRef;
 /** Evaluator-only canonical re-normalization; absent from the package root. */
 export declare function normalizePackageBindingDefinition(input: unknown): PackageBindingDefinition;
+/** Internal selector parsing shared by authoring and exact project linking. */
+export declare function parseRunTargetSelector(value: unknown, label: string): RunTargetRef;

package/libexec/evaluator/project-authoring-1.schema.json

@@ -20,6 +20,12 @@
       "minLength": 1,
       "maxLength": 1024
     },
+    "targetSelector": {
+      "type": "string",
+      "description": "An exact flow:<project-relative-path> or binding:<LocalName> selector. Jig additionally validates the prefix and canonical target identity.",
+      "minLength": 6,
+      "maxLength": 1029
+    },
     "discoverSource": {
       "type": "object",
       "properties": {
@@ -99,7 +105,7 @@
         "slots": {
           "type": "object",
           "additionalProperties": {
-            "$ref": "#/$defs/projectPath"
+            "$ref": "#/$defs/targetSelector"
           },
           "maxProperties": 256
         }

package/libexec/evaluator/project-evaluator-sdk.bundle.js

@@ -1783,6 +1783,12 @@ function normalizeJig(input, canonical) {
 function defineBinding(input) {
   return normalizeBinding(input, false);
 }
+function flowRef(path) {
+  return record({ kind: "flow", path: normalizeProjectPath(path, "Flow reference") });
+}
+function bindingRef(id) {
+  return record({ kind: "binding", id: validateLocalName(id, "Binding reference") });
+}
 function normalizeBinding(input, canonical) {
   const captured = snapshotJsonObject(input, "Binding definition");
   assertClosedObject(captured, canonical ? ["kind", "package", "settings", "slots"] : ["package", "settings", "slots"], "Binding definition");
@@ -1804,10 +1810,20 @@ function normalizeFlowSlots(value) {
   const output = Object.create(null);
   for (const name of Object.keys(input).sort(compareUtf8)) {
     validateLocalName(name, "slot name");
-    output[name] = normalizeProjectPath(input[name], `slot ${name}`);
+    const target = parseRunTargetSelector(input[name], `slot ${name}`);
+    output[name] = target.kind === "flow" ? `flow:${target.path}` : `binding:${target.id}`;
   }
   return Object.freeze(output);
 }
+function parseRunTargetSelector(value, label) {
+  if (typeof value !== "string")
+    throw new TypeError(`${label} must be a target selector`);
+  if (value.startsWith("flow:"))
+    return flowRef(normalizeProjectPath(value.slice(5), label));
+  if (value.startsWith("binding:"))
+    return bindingRef(validateLocalName(value.slice(8), label));
+  throw new TypeError(`${label} must select flow:<path> or binding:<id>`);
+}
 function normalizeSource(value, field, canonical) {
   if (value === undefined)
     throw new TypeError(`${field} cannot be undefined`);