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

package/README.md

@@ -7,8 +7,12 @@ has one finite command surface:
 jig init --bare <directory>
 jig review [project] [--yes]
 jig run <flow:path|binding:id> [--input JSON] [--timeout DURATION]
+jig --version
 ```
 
+`jig --version` prints the built package version without opening a project or
+acquiring a sandbox.
+
 There is no `jig setup`. `review` and `run` transparently acquire the rootless
 authority they need or fail closed.
 
@@ -33,14 +37,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 +150,7 @@ import { defineBinding } from "@jigging/jig";
 
 export default defineBinding({
   package: "./flows/reviewer",
-  slots: { research: "./flows/research" },
+  slots: { research: "flow:flows/research" },
 });
 ```
 
@@ -145,21 +159,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.d.ts

@@ -1 +1 @@
-export { defineBinding, defineJig, discover, type JigDefinitionInput, type PackageBindingInput, } from "./project/author.js";
+export { defineBinding, defineJig, discover, type JigDefinitionInput, type PackageBindingInput, } from './project/author.js';

package/dist/index.js

@@ -1783,6 +1783,18 @@ 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");
@@ -1794,7 +1806,12 @@ function normalizeBinding(input, canonical) {
   const packagePath = normalizeProjectPath(captured.package, "package");
   const settings = Object.hasOwn(captured, "settings") ? expectJsonObject(captured.settings, "settings") : emptyRecord();
   const slots = Object.hasOwn(captured, "slots") ? normalizeFlowSlots(captured.slots) : emptyRecord();
-  return record({ kind: "package", package: packagePath, settings, slots });
+  return record({
+    kind: "package",
+    package: packagePath,
+    settings,
+    slots
+  });
 }
 function normalizeFlowSlots(value) {
   const input = snapshotJsonObject(value, "slots");
@@ -1804,10 +1821,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

@@ -1,10 +1,10 @@
-import type { JsonObject } from "../json.js";
+import type { JsonObject } from '../json.js';
 export interface DiscoverySource {
-    readonly kind: "discover";
+    readonly kind: 'discover';
     readonly roots: readonly string[];
 }
 export interface MembersSource {
-    readonly kind: "members";
+    readonly kind: 'members';
     readonly paths: readonly string[];
 }
 export type ProjectSource = DiscoverySource | MembersSource;
@@ -18,16 +18,16 @@ export interface JigDefinitionInput {
     readonly bindings?: ProjectSourceInput;
 }
 export interface FlowRef {
-    readonly kind: "flow";
+    readonly kind: 'flow';
     readonly path: string;
 }
 export interface BindingRef {
-    readonly kind: "binding";
+    readonly kind: 'binding';
     readonly id: string;
 }
 export type RunTargetRef = FlowRef | BindingRef;
 export interface PackageBindingDefinition {
-    readonly kind: "package";
+    readonly kind: 'package';
     readonly package: string;
     readonly settings: JsonObject;
     readonly slots: Readonly<Record<string, string>>;
@@ -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;