@sublang/playbook 12.2.0 → 12.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sublang/playbook",
-  "version": "12.2.0",
+  "version": "12.2.2",
   "type": "module",
   "description": "Composable XState v5 playbook runtime with compiled Captain, CODE, REVIEW, DECIDE, and DEV workflows driven by GEARS specs.",
   "license": "Apache-2.0",

package/reference/sdlc/code.playbook/bin/repository-effects.js

@@ -1952,9 +1952,9 @@ async function releaseRepositoryClaim(claim, primaryError) {
   }
 }
 
-// A host binds the governed worktree identity for each durable call — fixed
-// at construction for the Captain host, resolved afresh from `cwd` for the
-// worktree host capability — and derives the schema-3 authority naming it.
+// A host binds the governed worktree identity for each durable call —
+// resolved afresh from `cwd` by both the Captain host and the worktree host
+// capability — and derives the schema-3 authority naming it.
 function bindHostWorktree(host) {
   return host.resolveIdentity().then((identity) => ({
     identity,
@@ -2978,33 +2978,43 @@ export async function createRepositoryEffectCapabilities({
   await sessionLease.assertOwner();
   const createdWriteAhead = await createWriteAhead(sessionLease);
   const ledgerService = assertEffectLedgerService(createdWriteAhead);
-  const identity = await resolveCanonicalGitWorktree(cwd);
+  // The governed worktree is bound afresh from `cwd` at every governed call
+  // and observation, so a working directory that is not a repository yet is
+  // governed from launch as its own prospective root and the `git init` a
+  // workflow's own setup step runs there keeps that one identity.
+  const resolveIdentity = async () => (await resolveGovernedWorktree(cwd)).identity;
+  const identity = await resolveIdentity();
   await sessionLease.assertOwner();
   const coordinator = createRepositoryEffectCoordinator();
 
   const capabilities = schema3Entries.map(
     ({ playbookId, requiredRoleIds, concurrentRoleSets }) => {
-      const authority = deepFreeze({
-        playbookId,
-        artifactSchema: 3,
-        cwd,
-        sessionId,
-        leaseOwnerToken: sessionLease.ownerToken,
-        canonicalWorktree: identity,
-        requiredRoleIds,
-        concurrentRoleSets,
-      });
+      const authorityNaming = (canonicalWorktree) =>
+        deepFreeze({
+          playbookId,
+          artifactSchema: 3,
+          cwd,
+          sessionId,
+          leaseOwnerToken: sessionLease.ownerToken,
+          canonicalWorktree,
+          requiredRoleIds,
+          concurrentRoleSets,
+        });
+      const authority = authorityNaming(identity);
       const host = Object.freeze({
-        resolveIdentity: async () => identity,
-        authorityFor: () => authority,
+        resolveIdentity,
+        authorityFor: (canonicalWorktree) =>
+          isDeepStrictEqual(canonicalWorktree, identity)
+            ? authority
+            : authorityNaming(canonicalWorktree),
       });
       const observe = async (options = {}) => {
         rejectBoundRepositoryOverride(options, 'observe', ['cwd']);
-        return observeResolvedWorktree(identity, options);
+        return observeGovernedWorktree(await resolveGovernedWorktree(cwd), options);
       };
       const acquire = async (options = {}) => {
         rejectBoundRepositoryOverride(options, 'acquire', ['cwd']);
-        return coordinator.acquire(identity.worktree, options);
+        return coordinator.acquire(cwd, options);
       };
       const runExclusive = async (options) => {
         return runDurableExclusive({
@@ -3139,11 +3149,11 @@ async function assertExistingDirectory(cwd, label) {
 // DR-046: the lease-free worktree capability an embedding host constructs
 // through `@sublang/playbook/host-capabilities`. It runs the same claim,
 // observation, receipt, completion, and deferred-operation path as the
-// Captain-hosted capability above, over one host-owned in-memory ledger.
-// Unlike that capability, it binds its worktree lazily: `cwd` need not be a
-// repository yet, and every governed call and observation re-resolves the
-// governed worktree of `cwd`, so a `git init` there — inside a governed call
-// or between calls — is observed rather than hidden behind a stale identity.
+// Captain-hosted capability above, over one host-owned in-memory ledger, and
+// binds its worktree the same lazy way: `cwd` need not be a repository yet,
+// and every governed call and observation re-resolves the governed worktree
+// of `cwd`, so a `git init` there — inside a governed call or between calls —
+// is observed rather than hidden behind a stale identity.
 export async function createWorktreeHostCapabilities(options = {}) {
   if (!isPlainObject(options)) {
     throw new TypeError('worktree host capability options must be an object');

package/slc/gears2fsm.md

@@ -385,6 +385,9 @@ implementation.
 
 A literal call shall retain the existing representation: `playbookId` is the
 literal target and `text` is the composed GEARS blockquote.
+Composing that text follows the quoted-relay rules of [link](link.md): a
+relayed value that is empty contributes no line, a multi-line value is quoted
+line by line, and the composer inserts no empty quoted line of its own.
 
 A dynamic call written
 ``Captain shall call playbook selected by `<target-field>`:`` shall declare the

package/slc/link.md

@@ -2413,6 +2413,10 @@ original template. Replacement strings are literal: placeholder-looking text
 inside Boss/catalog/plan/result values and JavaScript replacement tokens such
 as `$&`, `$$`, dollar-backtick, and `$'` shall not be interpreted or
 substituted again.
+A quoted relay line `> <placeholder>` whose value is empty shall be omitted
+from the composed text rather than left as an empty quoted line, a multi-line
+value shall be quoted line by line so every continuation line keeps its `>`
+marker, and the composer shall insert no empty quoted line of its own.
 
 ## Host adaptation (informative, not normative)
 

package/slc/text2gears.md

@@ -145,6 +145,11 @@ The guard name shall match the ASCII identifier pattern
 The bullet order is authoritative, guard names are unique within the item, and
 the description shall name every required output property with its exact
 case-sensitive identifier.
+An output property name shall match the same ASCII identifier pattern as a
+guard name: a kebab-case Source placeholder such as `<coder-output>` names the
+property `coderOutput` through the canonical kebab-token-to-camel-field mapping
+of [link](link.md), never a quoted kebab-case key, because downstream artifacts
+and calling playbooks consume these properties by name.
 
 A produced value consumed later shall have a declared producer: where any
 later item's blockquote reads a value through a `<placeholder>`, the item
@@ -242,6 +247,12 @@ text2gears shall emit an item whose behavior uses
 complete JSON-safe input-text template for that call.
 The literal target id shall be a stable configured playbook id, not a slash
 command or module specifier.
+A nested-call item shall carry no `Results:` label: the child's terminal result
+is its outcome, so Source's continuation after child success, abort, or failure
+stays as prose after the blockquote for
+[gears2fsm](gears2fsm.md#nested-playbook-calls) to route through
+`invoke.onDone` and `invoke.onError`; a `Results:` block on a nested-call item
+is malformed.
 
 Example: