@givolt/i3-composer-agent 2.3.7 → 3.1.0

package/skills/i3-enterprise-sop/references/verification/check_native_execution.py

@@ -0,0 +1,282 @@
+#!/usr/bin/env python3
+"""CodeBuddy native-method evidence/report audit, v0.1.1; read-only stdout.
+
+Separate from the direct-python helper profile in check_execution.py. A frozen
+caller scope defines evidence obligations; neither the model nor this checker
+creates business approval. Does not execute tools or modify project files.
+"""
+import argparse
+import hashlib
+import json
+from pathlib import Path
+import re
+import stat
+import sys
+
+START = '<!-- i3-sop-native-execution-report -->'
+END = '<!-- /i3-sop-native-execution-report -->'
+PROFILES = ('generation', 'status', 'plan', 'auto-preflight', 'standard')
+GATE_STATES = ('not_applicable', 'not_checked', 'pending', 'blocked', 'satisfied')
+INPUT_STATES = ('full', 'partial', 'not_read')
+
+
+def unique_object(pairs):
+    out = {}
+    for key, value in pairs:
+        if key in out:
+            raise ValueError('duplicate_json_key:' + key)
+        out[key] = value
+    return out
+
+
+def loads(text):
+    return json.loads(text, object_pairs_hook=unique_object,
+                      parse_constant=lambda value: (_ for _ in ()).throw(ValueError('invalid_constant:' + value)))
+
+
+def inventory(root):
+    files = {}
+    for p in Path(root).rglob('*'):
+        if '.git' in p.relative_to(root).parts:
+            continue
+        if p.is_symlink():
+            files[str(p.relative_to(root))] = {'symlink': str(p.readlink())}
+        elif p.is_file():
+            files[str(p.relative_to(root))] = {
+                'sha256': hashlib.sha256(p.read_bytes()).hexdigest(),
+                'mode': stat.S_IMODE(p.stat().st_mode)}
+    return files
+
+
+def content(block):
+    raw = block.get('content', '')
+    return raw if isinstance(raw, str) else '\n'.join(
+        row.get('text', '') for row in raw if isinstance(row, dict)) if isinstance(raw, list) else ''
+
+
+def outcome(result, tool):
+    if result is None:
+        return 'unconfirmed', 'missing_tool_result'
+    text = content(result)
+    error_carrier = result.get('is_error') or re.match(r'^\s*(?:Error:|Permission denied\b)', text)
+    if error_carrier and re.search(r'permission[^\n]*(denied|not allowed)|not (?:been )?granted permission', text, re.I):
+        return 'blocked', 'permission_denial'
+    if result.get('is_error') or re.match(r'^\s*Error:', text):
+        return 'failed', 'tool_flag_or_error_text'
+    if tool == 'Bash':
+        codes = re.findall(r'^Exit Code:\s*(-?\d+)\s*$', text, re.M | re.I)
+        if len(codes) != 1:
+            return 'unconfirmed', 'shell_exit_not_proven'
+        if int(codes[0]) != 0:
+            return 'failed', 'nonzero_process_exit'
+    return 'succeeded', 'tool_receipt'
+
+
+def trace_calls(events):
+    calls, results, issues = [], {}, []
+    ids = set()
+    for seq, event in enumerate(events):
+        blocks = (event.get('message') or {}).get('content', [])
+        if not isinstance(blocks, list):
+            continue
+        for block in blocks:
+            if not isinstance(block, dict):
+                continue
+            if event.get('type') == 'assistant' and block.get('type') == 'tool_use':
+                ident = block.get('id')
+                if not isinstance(ident, str) or ident in ids:
+                    issues.append('missing_or_duplicate_tool_call_id')
+                ids.add(ident)
+                calls.append({**block, 'seq': seq})
+            elif event.get('type') == 'user' and block.get('type') == 'tool_result':
+                ident = block.get('tool_use_id')
+                if ident not in ids or ident in results:
+                    issues.append('orphan_or_duplicate_tool_result')
+                results[ident] = (seq, block)
+    return calls, results, issues
+
+
+def report_block(text):
+    if text.count(START) != 1 or text.count(END) != 1:
+        raise ValueError('exactly_one_native_report_block_required')
+    block = text.split(START, 1)[1].split(END, 1)[0].strip()
+    match = re.fullmatch(r'```json\s*\n(.*?)\n```', block, re.S)
+    if not match:
+        raise ValueError('native_report_json_fence_required')
+    value = loads(match[1])
+    if not isinstance(value, dict) or set(value) != {'schemaVersion', 'failedAttempts', 'inputChecks', 'gates'}:
+        raise ValueError('native_report_root_contract_mismatch')
+    if type(value['schemaVersion']) is not int or value['schemaVersion'] != 1:
+        raise ValueError('native_report_version_mismatch')
+    for key, fields in [('failedAttempts', {'tool', 'subject', 'status'}),
+                        ('inputChecks', {'path', 'status'}), ('gates', {'id', 'status'})]:
+        if not isinstance(value[key], list) or any(not isinstance(row, dict) or set(row) != fields for row in value[key]):
+            raise ValueError('native_report_rows_invalid:' + key)
+        if any(not isinstance(item, str) for row in value[key] for item in row.values()):
+            raise ValueError('native_report_values_must_be_strings:' + key)
+    if any(row['status'] not in ('blocked', 'failed', 'unconfirmed') for row in value['failedAttempts']):
+        raise ValueError('native_attempt_state_invalid')
+    if any(row['status'] not in INPUT_STATES for row in value['inputChecks']):
+        raise ValueError('native_input_state_invalid')
+    if any(row['status'] not in GATE_STATES for row in value['gates']):
+        raise ValueError('native_gate_state_invalid')
+    return value
+
+
+def assess(root, scope, events, process, legacy_report=False):
+    root = Path(root).resolve()
+    if scope.get('profile') not in PROFILES:
+        raise ValueError('unknown_native_profile')
+    for key in ('requiredReads', 'reportInputs', 'allowedWrites', 'requiredSkills', 'files', 'gateExpectations'):
+        if key not in scope:
+            raise ValueError('frozen_scope_missing:' + key)
+    if any(path != '.codebuddy/.i3-composer-agent.json' for path in scope.get('requiredReadLines', {})):
+        raise ValueError('selected_line_exception_is_locator_metadata_only')
+    calls, results, trace_issues = trace_calls(events)
+    attempts, reads, writes, methods, forbidden = [], [], [], [], []
+    def relative(raw):
+        p = Path(raw)
+        p = (p if p.is_absolute() else root / p).resolve()
+        return str(p.relative_to(root)) if p.is_relative_to(root) else str(p)
+    for call in calls:
+        args = call.get('input') or {}
+        returned = results.get(call['id'])
+        receipt = returned[1] if returned else None
+        status, reason = outcome(receipt, call['name'])
+        text = content(receipt or {})
+        raw = args.get('file_path') or args.get('path')
+        path = relative(raw) if isinstance(raw, str) else None
+        tool = call['name']
+        subject = args.get('skill', '') if tool == 'Skill' else args.get('command', '') if tool == 'Bash' else path or ''
+        attempts.append({'ordinal': len(attempts) + 1, 'toolCallId': call['id'], 'traceLine': call['seq'] + 1,
+                         'resultLine': returned[0] + 1 if returned else None, 'tool': tool, 'subject': subject,
+                         'status': status, 'statusEvidence': reason})
+        if path and (Path(path).is_absolute() or path in scope.get('forbiddenReads', [])
+                     or any(path == prefix or path.startswith(prefix.rstrip('/') + '/')
+                            for prefix in scope.get('forbiddenAccessPrefixes', []))):
+            forbidden.append(path)
+        if tool == 'Read' and status == 'succeeded':
+            reads.append({'path': path, 'seq': returned[0], 'requestSeq': call['seq'],
+                          'lines': {int(n): value for n, value in re.findall(r'^\s*(\d+)→(.*)$', text, re.M)}})
+        if tool == 'Grep' and path in scope.get('requiredReadLines', {}) and status == 'succeeded':
+            # This exception is only for locator metadata; caller explicitly freezes those lines.
+            try:
+                parts = loads(text)
+            except ValueError:
+                parts = text.splitlines()
+            selected = {}
+            for part in parts if isinstance(parts, list) else []:
+                match = re.match(re.escape(str(root / path)) + r':(\d+):(.*)$', str(part))
+                if match:
+                    selected[int(match[1])] = match[2]
+            reads.append({'path': path, 'seq': returned[0], 'requestSeq': call['seq'], 'lines': selected})
+        if tool in ('Write', 'Edit'):
+            writes.append({'path': path, 'seq': call['seq'],
+                           'receiptSeq': returned[0] if returned else float('inf'), 'status': status})
+        if tool == 'Skill':
+            local = root / '.codebuddy/skills' / str(subject) / 'SKILL.md'
+            valid_name = bool(re.fullmatch(r'[a-z][a-z0-9-]*', str(subject)))
+            body = local.read_text().split('---', 2)[-1].strip() if valid_name and local.is_file() else None
+            methods.append({'name': subject, 'seq': returned[0] if returned else float('inf'), 'success': status == 'succeeded',
+                            'fullLocalBody': bool(body and body in text and str(local.parent) in text)})
+    first = min((row['seq'] for row in writes), default=float('inf'))
+    def coverage(path, before=float('inf'), after=-1, selected=None):
+        observed = {}
+        for read in reads:
+            if read['path'] == path and after < read['seq'] < before and (after < 0 or read['requestSeq'] > after):
+                observed.update(read['lines'])
+        p = root / path
+        lines = p.read_text().splitlines() if p.is_file() else []
+        wanted = list(selected) if selected is not None else list(range(1, len(lines) + 1))
+        correct = [n for n in wanted if 1 <= n <= len(lines) and observed.get(n) == lines[n - 1]]
+        state = 'full' if wanted and len(correct) == len(wanted) else 'partial' if observed else 'not_read'
+        return {'path': path, 'status': state, 'requiredLines': len(wanted), 'matchedLines': len(correct)}
+    required = [coverage(path, before=first, selected=scope.get('requiredReadLines', {}).get(path))
+                for path in scope['requiredReads']]
+    targets = []
+    for path in scope['allowedWrites']:
+        last = max((row['receiptSeq'] for row in writes if row['path'] == path and row['status'] == 'succeeded'), default=None)
+        targets.append(coverage(path, after=last if last is not None else float('inf')))
+    current = inventory(root)
+    changed = sorted(name for name in set(current) | set(scope['files']) if current.get(name) != scope['files'].get(name))
+    boundary_issues = ['unexpected_file_change:' + name for name in changed if name not in scope['allowedWrites']]
+    boundary_issues += ['write_attempt_outside_scope:' + str(row['path']) for row in writes if row['path'] not in scope['allowedWrites']]
+    boundary_issues += ['forbidden_or_outside_access:' + path for path in forbidden]
+    discipline = list(trace_issues)
+    allowed_tools = scope.get('tools', scope.get('allowedTools', []))
+    for row in attempts:
+        if row['tool'] not in allowed_tools:
+            discipline.append('tool_outside_scope:' + row['tool'])
+        if row['tool'] == 'Bash' and row['subject'] not in scope.get('allowedShellCommands', []):
+            discipline.append('shell_command_outside_exact_scope:' + row['subject'])
+        if row['status'] != 'succeeded':
+            discipline.append('tool_attempt_' + row['status'] + ':' + str(row['ordinal']))
+    method_issues = []
+    for skill in scope['requiredSkills']:
+        if not any(row['name'] == skill and row['success'] and row['fullLocalBody'] and row['seq'] < first for row in methods):
+            method_issues.append('required_native_skill_not_loaded:' + skill)
+    method_issues += ['forbidden_skill_loaded:' + row['name'] for row in methods if row['name'] in scope.get('forbiddenSkills', [])]
+    finals = [event for event in events if event.get('type') == 'result']
+    text = finals[-1].get('result', '') if finals else ''
+    report_issues, gate_issues = [], []
+    reporting_status = 'checked'
+    if legacy_report and START not in text:
+        reporting_status = 'not_checked_legacy'
+        report_issues.append('old_native_report_preserved_no_retroactive_format_claim')
+    else:
+        try:
+            report = report_block(text)
+            actual_failed = [{key: row[key] for key in ('tool', 'subject', 'status')}
+                             for row in attempts if row['status'] != 'succeeded']
+            if report['failedAttempts'] != actual_failed:
+                report_issues.append('failed_attempts_do_not_match_trace')
+            expected_inputs = [{'path': path, 'status': coverage(path, selected=scope.get('requiredReadLines', {}).get(path))['status']}
+                               for path in scope['reportInputs']]
+            if sorted(report['inputChecks'], key=lambda row: row['path']) != sorted(expected_inputs, key=lambda row: row['path']):
+                report_issues.append('input_claims_do_not_match_actual_reads')
+            expected_gates = [{'id': key, 'status': value} for key, value in scope['gateExpectations'].items()]
+            if sorted(report['gates'], key=lambda row: row['id']) != sorted(expected_gates, key=lambda row: row['id']):
+                gate_issues.append('gate_claims_differ_from_frozen_expectations')
+        except (ValueError, TypeError, KeyError) as exc:
+            report_issues.append(str(exc))
+            gate_issues.append('gate_report_not_validated')
+    if attempts and re.search(r'(?:^|[；;])\s*(?:无\s*(?:Bash\s*[/／、和]\s*)?工具调用|未调用任何工具)\s*(?:[。；;]|$)', text, re.M):
+        report_issues.append('narrative_no_tools_claim_contradicts_trace')
+    if any(row['tool'] == 'Bash' for row in attempts) and re.search(r'(?:^|[；;])\s*无\s*Bash(?:\s*[，,。；;]|\s*$)', text, re.M):
+        report_issues.append('narrative_no_bash_claim_contradicts_trace')
+    completed = bool(process.get('exitCode') == 0 and not process.get('timedOut') and finals and not finals[-1].get('is_error'))
+    sections = {
+        'completion': {'passed': completed},
+        'inputs': {'passed': all(row['status'] == 'full' for row in required), 'checks': required},
+        'targets': {'passed': all(row['status'] == 'full' for row in targets), 'checks': targets},
+        'boundaries': {'passed': not boundary_issues, 'issues': boundary_issues, 'changedFiles': changed},
+        'nativeMethods': {'passed': not method_issues, 'issues': method_issues, 'loads': methods},
+        'toolDiscipline': {'passed': not discipline, 'issues': discipline},
+        'reportConsistency': {'passed': not report_issues, 'status': reporting_status, 'issues': report_issues},
+        'gateReport': {'passed': not gate_issues, 'issues': gate_issues,
+                       'scope': 'matches caller test expectations; not human approval or semantic gate certification'}}
+    return {'checkerVersion': '0.1.1', 'profile': scope['profile'],
+            'passed': all(section['passed'] for section in sections.values()), **sections, 'attempts': attempts,
+            'proofScope': 'literal reads, local method load, file/tool boundary and structured report evidence; narrative semantics require human review',
+            'businessApproved': False, 'implementationApproved': False, 'published': False}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    for name in ('project-root', 'scope', 'trace', 'process'):
+        parser.add_argument('--' + name, required=True)
+    parser.add_argument('--legacy-report', action='store_true')
+    args = parser.parse_args()
+    try:
+        scope = loads(Path(args.scope).read_text())
+        events = [loads(line) for line in Path(args.trace).read_text().splitlines() if line.strip()]
+        result = assess(Path(args.project_root), scope, events, loads(Path(args.process).read_text()), args.legacy_report)
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+        return 0 if result['passed'] else 1
+    except (OSError, ValueError, TypeError, KeyError) as exc:
+        print(json.dumps({'passed': False, 'error': str(exc), 'businessApproved': False}, ensure_ascii=False))
+        return 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())

package/skills/i3-enterprise-sop/references/verification/check_reads.py

@@ -0,0 +1,348 @@
+"""Read-only checker for CodeBuddy stream-json evidence. No project or report writes."""
+import json,re
+from pathlib import Path
+
+def assess(project_root, scope, events):
+    root=Path(project_root).resolve()
+    def relative(raw):
+        p=Path(raw);p=(p if p.is_absolute() else root/p).resolve()
+        return str(p.relative_to(root)) if p.is_relative_to(root) else str(p)
+    calls=[];results={};finals=[]
+    for seq,event in enumerate(events):
+        if event.get('type')=='result':finals.append(event)
+        message=event.get('message',{})
+        if not isinstance(message,dict):continue
+        for block in message.get('content',[]):
+            if not isinstance(block,dict):continue
+            if event.get('type')=='assistant' and block.get('type')=='tool_use':
+                calls.append({**block,'event':seq})
+            if event.get('type')=='user' and block.get('type')=='tool_result':
+                results[block['tool_use_id']]={**block,'receiptEvent':seq}
+    reads=[];writes=[];errors=[]
+    for call in calls:
+        inp=call.get('input',{});result=results.get(call['id'])
+        raw=inp.get('file_path') or inp.get('path')
+        path=relative(raw) if raw else None
+        success=result is not None and not result.get('is_error',False)
+        item={'tool':call['name'],'path':path,'event':call['event'],
+              'receiptEvent':result['receiptEvent'] if result else float('inf'),'successful':success}
+        if call['name']=='Read':
+            data=result.get('content',[]) if result else []
+            text=data if isinstance(data,str) else '\n'.join(x.get('text','') for x in data if isinstance(x,dict))
+            reads.append({**item,'lines':[int(n) for n in re.findall(r'^\s*(\d+)→',text,re.M)]})
+        elif call['name'] in ['Write','Edit','Bash','PowerShell','NotebookEdit','Skill','Task','Agent']:
+            writes.append(item)
+        if result and result.get('is_error'):errors.append(item)
+    allowed={relative(p) for p in scope.get('allowedWrites',[])}
+    first_write=min((x['event'] for x in writes if x['successful']),default=float('inf'))
+    coverage=[]
+    for raw in scope['requiredReads']:
+        path=relative(raw);p=root/path
+        count=scope.get('beforeLineCounts',{}).get(raw)
+        if count is None:count=len(p.read_text().splitlines()) if p.is_file() else None
+        observed=[x for x in reads if x['path']==path and x['successful'] and x['receiptEvent']<first_write]
+        lines={n for x in observed for n in x['lines']}
+        full=count is not None and bool(observed) and all(n in lines for n in range(1,count+1))
+        coverage.append({'path':path,'exists':p.is_file(),'expectedLines':count,'successfulRead':bool(observed),'fullRead':full})
+    missing=[x['path'] for x in coverage if not x['successfulRead']]
+    partial=[x['path'] for x in coverage if x['successfulRead'] and not x['fullRead']]
+    explicit_external={relative(p) for p in scope['requiredReads'] if Path(relative(p)).is_absolute()}
+    forbidden=[]
+    for read in reads:
+        p=read['path']
+        if read['successful'] and ((Path(p).is_absolute() and p not in explicit_external) or any(p==relative(x) or p.startswith(relative(x).rstrip('/')+'/') for x in scope.get('forbiddenAccessPrefixes',[]))):forbidden.append(p)
+    targets=[]
+    for path in sorted(allowed):
+        p=root/path;changes=[x for x in writes if x['path']==path and x['successful'] and x['tool'] in ['Write','Edit']]
+        last=max((x['receiptEvent'] for x in changes),default=float('inf'))
+        final_reads=[x for x in reads if x['path']==path and x['successful'] and x['event']>last and x['receiptEvent']>last]
+        count=len(p.read_text().splitlines()) if p.is_file() else None
+        lines={n for x in final_reads for n in x['lines']}
+        full=bool(changes and final_reads) and count is not None and all(n in lines for n in range(1,count+1))
+        targets.append({'path':path,'lastWriteEvent':last if changes else None,'finalLines':count,'fullReadAfterLastEdit':full})
+    failures=[]
+    if not finals or finals[-1].get('is_error',False):failures.append('native_final_not_proven')
+    if missing:failures.append('required_read_missing')
+    if partial:failures.append('required_read_incomplete')
+    if forbidden:failures.append('forbidden_source_read')
+    if any(x['tool'] not in ['Write','Edit'] or x['path'] not in allowed for x in writes):failures.append('tool_or_write_boundary')
+    if any(not x['fullReadAfterLastEdit'] for x in targets):failures.append('final_full_read_incomplete')
+    return {'format':'i3-read-evidence/v1','passed':not failures,'failures':failures,'requiredReadCoverage':coverage,
+            'missingReads':missing,'partialReads':partial,'forbiddenReads':sorted(set(forbidden)),'targetChecks':targets,
+            'observedReads':reads,'observedWrites':writes,'toolErrors':errors,
+            'proofScope':'actual native reads and final read coverage only; not semantic correctness, approval or runtime interception'}
+
+def _schema_errors(value, node, schema, location='$'):
+    """Validate only the keywords used by our bundled contract, without dependencies.
+
+    This is not a general JSON Schema engine. Unknown keywords fail closed.
+    """
+    supported = {'$schema', '$id', 'title', 'description', 'type', 'required', 'properties',
+                 'additionalProperties', 'items', 'minItems', 'minimum', 'minLength',
+                 'enum', '$ref', '$defs'}
+    if set(node) - supported:
+        raise ValueError('unsupported bundled schema keyword at ' + location)
+    if '$ref' in node:
+        prefix = '#/$defs/'
+        ref = node['$ref']
+        if not ref.startswith(prefix):
+            raise ValueError('only bundled local schema references are supported')
+        return _schema_errors(value, schema['$defs'][ref[len(prefix):]], schema, location)
+    types = {'object': lambda x: isinstance(x, dict), 'array': lambda x: isinstance(x, list),
+             'string': lambda x: isinstance(x, str), 'integer': lambda x: type(x) is int}
+    kind = node.get('type')
+    if kind and (kind not in types or not types[kind](value)):
+        return [location + ': expected ' + str(kind)]
+    errors = []
+    if 'enum' in node and value not in node['enum']:
+        errors.append(location + ': value outside enum')
+    if kind == 'object':
+        properties = node.get('properties', {})
+        errors += [location + '.' + key + ': missing' for key in node.get('required', []) if key not in value]
+        if node.get('additionalProperties') is False:
+            errors += [location + '.' + key + ': unknown field' for key in value if key not in properties]
+        for key in value.keys() & properties.keys():
+            errors += _schema_errors(value[key], properties[key], schema, location + '.' + key)
+    elif kind == 'array':
+        if len(value) < node.get('minItems', 0):
+            errors.append(location + ': too few items')
+        for index, item in enumerate(value):
+            errors += _schema_errors(item, node.get('items', {}), schema, f'{location}[{index}]')
+    elif kind == 'string' and len(value.strip()) < node.get('minLength', 0):
+        errors.append(location + ': empty string')
+    elif kind == 'integer' and value < node.get('minimum', value):
+        errors.append(location + ': below minimum')
+    return errors
+
+
+def _source_role_bindings(scope):
+    """One caller-owned role table for both schema generation and evidence checks."""
+    if not isinstance(scope, dict):
+        raise ValueError('review scope must be an object')
+    roles = scope.get('sourceRoles', {})
+    required = scope.get('requiredSourceRoles', [])
+    if (not isinstance(roles, dict)
+            or not all(isinstance(k, str) and isinstance(v, str) and k.strip() and v.strip() for k, v in roles.items())
+            or not isinstance(required, list)
+            or any(not isinstance(k, str) or k not in roles for k in required)):
+        raise ValueError('sourceRoles/requiredSourceRoles must be explicit caller bindings')
+    return dict(roles), list(required)
+
+
+def build_review_schema(scope):
+    """Build a fresh CLI-compatible job schema from the bundled schema and scope.
+
+    Role enums are bound before generation. No project, scope or report writes.
+    The evidence validator uses the same _source_role_bindings function.
+    """
+    roles, _ = _source_role_bindings(scope)
+    schema = json.loads(Path(__file__).with_name('review-output.schema.json').read_text())
+    properties = schema['$defs']['reference']['properties']
+    if roles:
+        properties['role']['enum'] = sorted(roles)
+    else:
+        properties.pop('role', None)
+
+    def inline(node):
+        if isinstance(node, list):
+            return [inline(x) for x in node]
+        if not isinstance(node, dict):
+            return node
+        if '$ref' in node:
+            prefix = '#/$defs/'
+            if not node['$ref'].startswith(prefix):
+                raise ValueError('only bundled local schema references are supported')
+            return inline(schema['$defs'][node['$ref'][len(prefix):]])
+        return {k: inline(v) for k, v in node.items() if k not in ['$defs', '$schema', '$id']}
+    return inline(schema)
+
+
+def _unique_object(pairs):
+    result = {}
+    for key, value in pairs:
+        if key in result:
+            raise ValueError('duplicate JSON key: ' + key)
+        result[key] = value
+    return result
+
+
+def _invalid_constant(value):
+    raise ValueError('nonstandard JSON constant: ' + value)
+
+
+def check_review(project_root, events, assessment, scope=None):
+    scope = scope or {}
+    issues, checked = [], []
+    def fail(code, detail):
+        issues.append({'code': code, 'detail': detail})
+    def result(**extra):
+        return {'passed': not issues, 'errors': [x['detail'] for x in issues],
+                'errorCodes': sorted({x['code'] for x in issues}), 'issues': issues,
+                'quotes': checked, 'contract': 'i3-enterprise-sop-review-output/v1', **extra}
+    finals = [x for x in events if x.get('type') == 'result']
+    text = finals[-1].get('result', '') if finals else ''
+    carrier = scope.get('reviewCarrier', 'text')
+    if carrier not in ['text', 'structured_output']:
+        fail('review_carrier_invalid', 'unsupported explicitly selected review carrier')
+        return result()
+    if carrier == 'structured_output':
+        if not finals or 'structured_output' not in finals[-1]:
+            fail('review_output_missing', 'requested native structured_output missing; no text fallback')
+            return result()
+        payload = finals[-1]['structured_output']
+        calls, successful = {}, set()
+        for event in events:
+            message = event.get('message', {})
+            content = message.get('content', []) if isinstance(message, dict) else []
+            if not isinstance(content, list):
+                continue
+            for block in content:
+                if not isinstance(block, dict):
+                    continue
+                if block.get('type') == 'tool_use' and block.get('name') == 'StructuredOutput':
+                    calls[block.get('id')] = block.get('input')
+                elif block.get('type') == 'tool_result' and not block.get('is_error', False):
+                    successful.add(block.get('tool_use_id'))
+        if not any(tool_id in successful and value == payload for tool_id, value in calls.items()):
+            fail('review_structured_output_unproven', 'no matching successful native StructuredOutput tool/result pair')
+            return result()
+        try:
+            raw = json.dumps(payload, ensure_ascii=False, allow_nan=False)
+        except (ValueError, TypeError) as error:
+            fail('review_json_invalid', str(error))
+            return result()
+    else:
+        if not isinstance(text, str) or not text.strip():
+            fail('review_output_missing', 'native final report text missing')
+            return result()
+        blocks = re.findall(r'```json[ \t]*\r?\n(.*?)\r?\n```', text, re.S)
+        if len(blocks) > 1:
+            fail('review_json_ambiguous', 'expected one JSON object, found multiple JSON blocks')
+            return result()
+        raw = blocks[0] if blocks else text.strip()
+    try:
+        report = json.loads(raw, object_pairs_hook=_unique_object, parse_constant=_invalid_constant)
+    except (ValueError, TypeError) as error:
+        fail('review_json_invalid', str(error))
+        return result(parseError={'message': str(error), 'line': getattr(error, 'lineno', None),
+                                  'column': getattr(error, 'colno', None), 'position': getattr(error, 'pos', None)})
+    checked_report = check_report(project_root, report, assessment, scope)
+    checked_report['carrier'] = carrier
+    checked_report['nativeCarrierProven'] = carrier == 'structured_output'
+    return checked_report
+
+
+def check_report(project_root, report, assessment, scope=None):
+    """Check report content against source/read evidence; no native-origin claim.
+
+    The caller must record the origin of a separately corrected report. Calling
+    this function does not turn that report into a new native model result.
+    """
+    root = Path(project_root).resolve()
+    scope = scope or {}
+    carrier = 'report-object'
+    issues, checked = [], []
+    def fail(code, detail):
+        issues.append({'code': code, 'detail': detail})
+    def result(**extra):
+        return {'passed': not issues, 'errors': [x['detail'] for x in issues],
+                'errorCodes': sorted({x['code'] for x in issues}), 'issues': issues,
+                'quotes': checked, 'contract': 'i3-enterprise-sop-review-output/v1', **extra}
+    try:
+        schema = json.loads(Path(__file__).with_name('review-output.schema.json').read_text())
+        schema_errors = _schema_errors(report, schema, schema)
+    except (ValueError, KeyError, OSError) as error:
+        fail('review_contract_invalid', str(error))
+        return result()
+    if not schema_errors:
+        for group in ['findings', 'checkedFacts']:
+            ids = [x['id'] for x in report[group]]
+            if len(ids) != len(set(ids)):
+                schema_errors.append(group + ': duplicate stable ID')
+    if schema_errors:
+        for error in schema_errors:
+            fail('review_schema_invalid', error)
+        return result()
+
+    def relative(raw_path):
+        p = Path(raw_path)
+        p = (p if p.is_absolute() else root / p).resolve()
+        return str(p.relative_to(root)) if p.is_relative_to(root) else str(p)
+    try:
+        roles, required_roles = _source_role_bindings(scope)
+    except ValueError as error:
+        fail('review_role_scope_invalid', str(error))
+        return result()
+    roles = {name: relative(path) for name, path in roles.items()}
+    read_lines = {}
+    for item in assessment['observedReads']:
+        if item['successful']:
+            read_lines.setdefault(item['path'], set()).update(item['lines'])
+    proven_roles = set()
+    for group in ['findings', 'checkedFacts']:
+        for index, item in enumerate(report[group]):
+            for side in ['target', 'source']:
+                ref = item[side]
+                label = f'{group}[{index}].{side}'
+                path = relative(ref['path'])
+                start, end = ref['startLine'], ref.get('endLine', ref['startLine'])
+                bound_role = ref.get('role')
+                role_matches = bound_role is None
+                if bound_role is not None:
+                    if bound_role not in roles:
+                        fail('review_source_role_unbound', label + ': unbound role ' + bound_role)
+                    elif roles[bound_role] != path:
+                        fail('review_source_role_mismatch', label + ': role does not match caller-bound path')
+                    else:
+                        role_matches = True
+                observed = start <= end and all(n in read_lines.get(path, set()) for n in range(start, end + 1))
+                quote_matches = False
+                if start > end:
+                    fail('review_reference_range_invalid', label + ': endLine precedes startLine')
+                else:
+                    # Do not open an arbitrary external path merely because the model cites it.
+                    p = root / path
+                    explicit_external = {relative(x) for x in scope.get('requiredReads', [])}
+                    permitted = p.is_relative_to(root) or path in explicit_external
+                    try:
+                        lines = p.read_text().splitlines() if permitted and p.is_file() else []
+                        quote_matches = end <= len(lines) and ref['quote'] in '\n'.join(lines[start-1:end])
+                    except (OSError, UnicodeError):
+                        pass
+                    if not quote_matches:
+                        fail('review_quote_mismatch', label + ': quote does not match referenced current file/lines')
+                if not observed:
+                    fail('review_reference_not_read', label + ': cited lines lack successful native Read evidence')
+                if bound_role and role_matches and observed and quote_matches:
+                    proven_roles.add(bound_role)
+                checked.append({'group': group, 'index': index, 'role': side, 'path': path,
+                                'sourceRole': bound_role, 'quoteMatches': quote_matches,
+                                'citedLinesActuallyRead': observed, 'sourceRoleMatches': role_matches})
+    for name in required_roles:
+        if name not in proven_roles:
+            fail('review_source_role_missing', 'required role lacks proven reference: ' + name)
+    return result(verdict=report['verdict'], carrier=carrier, sourceRoleEvidence=sorted(proven_roles),
+                  scope='structure, exact quotes, actual Read ranges and caller-bound roles only; not semantic correctness or approval')
+
+def main():
+    import argparse,sys
+    parser=argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--project-root',required=True)
+    parser.add_argument('--scope',required=True,help='Verification scope only; not business handoff.json')
+    parser.add_argument('--trace',required=True,help='CodeBuddy stream-json trace')
+    parser.add_argument('--review-quotes',action='store_true')
+    args=parser.parse_args()
+    try:
+        scope=json.loads(Path(args.scope).read_text())
+        events=[json.loads(line) for line in Path(args.trace).read_text().splitlines() if line.strip()]
+        if not isinstance(scope.get('requiredReads'),list):raise ValueError('scope.requiredReads must be a list')
+        result=assess(args.project_root,scope,events)
+        if args.review_quotes:
+            quote_check=check_review(args.project_root,events,result,scope);result['reviewQuoteCheck']=quote_check
+            if not quote_check['passed']:result['failures'].extend(quote_check['errorCodes']);result['passed']=False
+    except (ValueError,KeyError,TypeError,OSError,UnicodeError) as error:
+        result={'format':'i3-read-evidence/v1','passed':False,'failures':['invalid_or_unsupported_evidence'],'detail':str(error)}
+    print(json.dumps(result,ensure_ascii=False,indent=2))
+    return 0 if result['passed'] else 1
+
+if __name__=='__main__':raise SystemExit(main())