devlyn-cli 4.3.21 → 4.3.24

package/config/skills/_shared/harness-store.py

@@ -169,16 +169,26 @@ def packet_schema(packet):
     resource(packet.get("workerPrompt"))
 
 
-def verify_packet(packet, path, skills):
+def verify_packet(packet, path, skills, *, accepted_receipt=None):
     packet_schema(packet)
     if packet.get("schema_version", 1) == 1:
         return  # Preserve v1 execution without upgrading its resources.
     receipt = packet.get("receipt")
     require(isinstance(receipt, str) and "\0" not in receipt and Path(receipt).is_absolute()
             and Path(receipt).name == "receipt.json" and Path(receipt).parent.parent.name == "devlyn-completion"
-            and Path(receipt) == Path(path).with_name("receipt.json"),
+            and (accepted_receipt is not None or Path(receipt) == Path(path).with_name("receipt.json")),
             "malformed packet receipt path")
-    binding = read_binding(Path(receipt).parent.parent.parent)
+    common = Path(receipt).parent.parent.parent
+    if accepted_receipt is not None:
+        saved = accepted_receipt
+        require(saved.get('acceptance') and saved.get('id') == Path(receipt).parent.name
+                and saved.get('common_gitdir') == str(common) and saved.get('worktree') == packet['worktree'],
+                'accepted packet receipt binding changed')
+        original = Path(receipt)
+        archived = common / 'devlyn-completion/retired' / (
+            saved['id'] + '.' + saved.get('storage', {}).get('request', {}).get('operation_id', '')) / 'receipt.json'
+        require(Path(path).with_name('receipt.json') in (original, archived), 'accepted packet custody path changed')
+    binding = read_binding(common)
     if packet["harness"] is None:
         require(binding is None, "bound task packet has no harness/defaults source")
         # An unbound installation's own defaults change with its normal updates: never gate acceptance or delivery on
@@ -193,15 +203,17 @@ def verify_packet(packet, path, skills):
     defaults = {"source": "release", **binding["defaults"]}
     require(packet["methodology"]["defaults"] == defaults, "packet defaults differ from queue binding")
     expected_runner = [str(Path(ref["root"]) / "config/skills/devlyn-ideate/scripts/acceptance.py"),
-                       "run", "--packet", str(path)]
+                       "run", "--packet", str(Path(receipt).with_name('packet.json'))]
     require(isinstance(packet.get("runner"), list) and packet["runner"][1:] == expected_runner, "packet runner differs from bound release")
     prompt = packet["workerPrompt"]
-    require(prompt["path"] == str(Path(path).parent / "worker-prompt.md") and file_identity(prompt["path"]) == prompt,
+    actual_prompt = file_identity(Path(path).parent / 'worker-prompt.md')
+    require(prompt["path"] == str(Path(receipt).parent / "worker-prompt.md") and actual_prompt['sha256'] == prompt['sha256'],
             "worker prompt changed or missing; restore the bound resource")
     for entry in packet["methodology"]["projectInstructions"]:
         name = Path(entry["path"]).name
         require(name in ("CLAUDE.md", "AGENTS.md") and entry["path"] == str(Path(packet["worktree"]) / name),
                 "project instruction path escapes packet worktree")
-        committed = subprocess.run(["git", "-C", packet["worktree"], "cat-file", "blob", f"{packet['inputs_sha']}:{name}"], capture_output=True)
+        repository = ['--git-dir', str(common)] if accepted_receipt is not None else ['-C', packet['worktree']]
+        committed = subprocess.run(["git", *repository, "cat-file", "blob", f"{packet['inputs_sha']}:{name}"], capture_output=True)
         require(committed.returncode == 0 and hashlib.sha256(committed.stdout).hexdigest() == entry["sha256"],
                 f"project instruction differs from inputs commit: {name}")

package/config/skills/_shared/runtime-principles.md

@@ -1,4 +1,4 @@
-The following Devlyn instructions are defaults for this session. Applicable explicit user instructions and native owner/project instructions take precedence over these defaults. This delegation applies only to the Devlyn defaults below; it does not change other engine instructions or permissions.
+The following Devlyn instructions are defaults for this session. Explicit user and native owner/project instructions take precedence, except a Devlyn managed block (devlyn:instructions markers), which these defaults replace. They change no other engine instructions or permissions.
 
 # Project Instructions
 
@@ -15,7 +15,7 @@ Seven rules govern every change. Cite them by name when a decision touches one.
 1. **No workaround** — fix the root cause, never the symptom. No `any`, no `@ts-ignore`, no silent `catch`, no hardcoded fallback that hides a broken contract. No config bypasses.
 2. **No overengineering** — smallest sufficient change, one responsibility per module. New abstractions need an observed failure. Subtractive-first: ask "what can I delete instead?" before writing anything new. Remove code your change makes unused; only report unrelated pre-existing dead code.
 3. **No guesswork** — verify with the actual files, logs, diffs, and run output before forming conclusions. State the falsifiable prediction BEFORE the experiment; record raw results AFTER. Retroactive prediction edits are dishonest.
-4. **Worldclass** — code that survives review at a non-trivial codebase. Zero CRITICAL, zero HIGH security/design findings on the shippable path.
+4. **Worldclass** — zero CRITICAL, zero HIGH security/design findings on the shippable path. Any review is one pass in which every reviewer, including each one the user requires, reads the source the checks ran on; fix each finding or reject it with a reason, re-check the fixes and the invariants they touch, and repeat the full review only while a CRITICAL or HIGH finding remains.
 5. **Best practice** — idiomatic for the language and framework. Use standard primitives; do not hand-roll what the library already provides.
 6. **Optimized** — use efficient code and avoid unnecessary work without sacrificing correctness or the user's requirements.
 7. **Production ready** — error states are explicit and visible; behavior under failure is what the user expects, not silent corruption.

package/config/skills/_shared/storage-checkout.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+"""Protocol-1 finite checkout adapter. Rust owns the allocation subreceipt."""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path, PurePosixPath, PureWindowsPath
+import runpy
+import subprocess
+
+storage = runpy.run_path(str(Path(__file__).with_name('storage-client.py')))
+require = storage['require']
+validate = storage['validate']
+StorageRefusal = storage['StorageRefusal']
+
+
+def validate_request(op, request, *, windows=None):
+    destination = {'state': ('absent', 'precreated_empty'), 'path': 'str'}
+    if type(request.get('destination')) is dict and request['destination'].get('state') == 'precreated_empty':
+        destination['identity'] = 'identity'
+    shapes = {
+        'capabilities': {},
+        'allocate': {'adapter_protocol': 'u32', 'operation_id': 'str', 'control_directory': 'str',
+                     'repository': 'str', 'baseline': 'str', 'branch': 'str', 'owner': 'owner',
+                     'external_receipt': 'str', 'destination': destination, 'cache_policy': ('cargo_worktree_v1',)},
+        'reconcile-for-removal': {'adapter_protocol': 'u32', 'allocation_operation_id': 'str',
+                                 'external_receipt': 'str', 'removal_operation_id': 'str', 'worktree_identity?': 'identity?'},
+        'unenroll': {'adapter_protocol': 'u32', 'operation_id': 'str'},
+    }
+    require(op in shapes, 'unknown checkout adapter operation', 'storage_invalid')
+    validate(request, shapes[op], exact=True, windows=windows)
+    if op == 'capabilities':
+        return request
+    require(request['adapter_protocol'] == 1, 'unsupported checkout adapter protocol', 'storage_invalid')
+    for field in ('operation_id', 'allocation_operation_id', 'removal_operation_id'):
+        if field in request:
+            storage['canonical_operation'](request[field])
+    path_type = PureWindowsPath if (os.name == 'nt' if windows is None else windows) else PurePosixPath
+    for name in ('repository', 'control_directory', 'external_receipt'):
+        if name in request:
+            path = path_type(request[name])
+            require(path.is_absolute() and '..' not in path.parts and '.' not in request[name].replace('\\', '/').split('/'),
+                    'adapter paths must be absolute without traversal', 'storage_invalid')
+    if op == 'allocate':
+        import re
+        require(re.fullmatch(r'(?:[0-9a-f]{40}|[0-9a-f]{64})', request['baseline']),
+                'baseline must be an exact commit', 'storage_invalid')
+    return request
+
+
+def validate_closure(value):
+    require(type(value) is dict, 'positive reservation closure missing')
+    tag = value.get('established_by')
+    shapes = {'released': {'established_by': ('released',), 'reservation': 'reservation'},
+              'authority_expired': {'established_by': ('authority_expired',), 'operation_id': 'str'},
+              'never_admitted': {'established_by': ('never_admitted',), 'operation_id': 'str'},
+              'legacy_unreserved': {'established_by': ('legacy_unreserved',), 'receipt_version': 'u32'}}
+    require(tag in shapes, 'positive reservation closure missing')
+    validate(value, shapes[tag])
+    return value
+
+
+def decode_reply(raw, op, code):
+    require(raw.endswith(b'\n') and b'\n' not in raw[:-1] and len(raw) <= storage['MAX_REPLY'],
+            'uncertain adapter output; replay the saved request')
+    value = storage['loads'](raw)
+    validate(value, {'adapter_protocol': 'u32', 'op': (op,)})
+    require(value['adapter_protocol'] == 1 and ('result' in value) != ('error' in value), 'invalid adapter envelope')
+    if 'error' in value:
+        error = value['error']
+        validate(error, {'code': 'str', 'phase': 'str', 'retryable': 'bool', 'receipt': 'str?', 'diagnostic': 'str'})
+        require(code == 2, 'adapter refusal exit mismatch')
+        refusal = StorageRefusal('storage_invalid' if error['code'] == 'invalid_request' else error['code'],
+                                 error['diagnostic'], operation=op, phase=error['phase'])
+        refusal.retryable = error['retryable']
+        raise refusal
+    require(code == 0, 'uncertain adapter exit; replay the saved request')
+    result = value['result']
+    if op == 'capabilities':
+        validate(result, {'cli_checkout_v1': 'bool', 'adapter_protocol': 'u32', 'receipt_version': 'u32',
+                          'destination_modes': ['str'], 'helper_release': {'version': 'str', 'os': 'str', 'arch': 'str', 'sha256': 'str'}})
+        require(result['cli_checkout_v1'] and result['adapter_protocol'] == 1 and result['receipt_version'] == 3,
+                'incompatible checkout helper', 'storage_unsupported')
+    elif op == 'allocate':
+        validate(result, {'allocation_binding': {'baseline': 'str', 'branch': 'str', 'destination': 'str',
+                          'destination_mode': {'state': ('absent', 'precreated_empty'), 'identity?': 'identity'},
+                          'owner': 'owner', 'publication_owner': 'owner', 'receipt': 'str',
+                          'adapter': {'operation_id': 'str', 'repository': 'str', 'control_directory': 'str', 'external_receipt': 'str'}},
+                          'receipt': 'str', 'publications': ['published'], 'warnings': ['warning']})
+        validate_closure(result.get('closure_result'))
+    elif op == 'reconcile-for-removal':
+        validate(result, {'operation_id': 'str', 'cache_ids': ['str']})
+        require(len(result['cache_ids']) == len(set(result['cache_ids'])), 'duplicate removal cache ID')
+        validate_closure(result.get('closure_result'))
+    return result
+
+
+def call(registration, op, request):
+    """One attempt; uncertain stdout leaves the caller's durable request unchanged."""
+    validate_request(op, request)
+    raw = json.dumps(request, ensure_ascii=False, separators=(',', ':'), allow_nan=False).encode()+b'\n'
+    require(len(raw)-1 <= storage['MAX_REQUEST'], 'adapter request exceeds limit', 'storage_invalid')
+    try:
+        require(storage['regular_digest'](registration['helper_path']) == registration['helper_release']['sha256'],
+                'enrolled helper changed')
+        # No timeout: killing an allocating holder can turn replay into crash recovery.
+        # Spool output to disk so an invalid helper cannot exhaust Python memory.
+        import tempfile
+        with tempfile.TemporaryFile() as output, tempfile.TemporaryFile() as diagnostic:
+            process = subprocess.run([registration['helper_path'], 'storage-checkout', op, '--json'],
+                                     input=raw, stdout=output, stderr=diagnostic)
+            output.seek(0)
+            reply = output.read(storage['MAX_REPLY']+1)
+        return decode_reply(reply, op, process.returncode)
+    except OSError as exc:
+        raise StorageRefusal('storage_unavailable', f'helper outcome uncertain: {exc}; replay saved request',
+                             operation=op, phase='helper') from exc