@runweave/server-linux-x64 0.1.8 → 0.1.10

package/payload/plugins/toolkit/skills/youtube-reading/scripts/youtube_reading.py

@@ -0,0 +1,314 @@
+#!/usr/bin/env python3
+"""YouTube source preparation; the calling Agent performs review and translation."""
+import argparse
+import json
+from pathlib import Path
+import re
+import sys
+import time
+from urllib.parse import parse_qs, urlparse
+
+sys.dont_write_bytecode = True
+
+import artifacts as a
+import runtime as r
+
+
+def normalize_url(url):
+    try:
+        p = urlparse(url)
+        port = p.port
+    except ValueError as e:
+        raise a.JobError('INVALID_URL', '无效的视频链接。') from e
+    if (p.scheme not in {'https', 'http'} or p.hostname not in
+            {'youtube.com', 'www.youtube.com', 'm.youtube.com', 'youtu.be', 'www.youtu.be'} or
+            p.username or p.password or port not in {None, 443, 80} or
+            re.search(r'[\s<>"\x27;|\\]', url)):
+        raise a.JobError('INVALID_URL', '仅支持 YouTube 单视频链接。')
+    if p.hostname.endswith('youtu.be'):
+        video_id = p.path.lstrip('/')
+    elif p.path == '/watch':
+        video_id = parse_qs(p.query).get('v', [''])[0]
+    elif p.path.startswith('/shorts/'):
+        video_id = p.path[len('/shorts/'):]
+    else:
+        video_id = ''
+    if not re.fullmatch(r'[A-Za-z0-9_-]{11}', video_id):
+        raise a.JobError('INVALID_URL', '链接缺少有效 video ID；频道与纯播放列表不受支持。')
+    return video_id, 'https://www.youtube.com/watch?v=' + video_id
+
+
+def save(work, manifest):
+    manifest['updated_at'] = a.now()
+    a.write_json(work / 'manifest.json', manifest)
+
+
+def status(job, manifest, cache_hit=False):
+    return {'status': manifest['stage'], 'job_dir': str(job), 'manifest': str(job / '.work/manifest.json'),
+            'cache_hit': cache_hit, 'acquired_at': manifest.get('acquired_at'),
+            'next': 'review chunks, write review.json and guide.txt, then finalize' if manifest['stage'] == 'awaiting_ai' else None,
+            'reading': str(job / 'reading.md') if manifest['stage'] == 'complete' else None,
+            'quality_hints': manifest.get('quality_hints', [])}
+
+
+def require_runtime(root):
+    result = r.doctor(root)
+    if not result['ok']:
+        raise a.JobError('RUNTIME_INVALID', '; '.join(result['issues']))
+
+
+def material_identity():
+    return a.identity({'runtime_lock': r.LOCK, 'material_version': 4})
+
+
+def prepare(url, output_root, runtime_root, timeout_seconds=None, adapter=None):
+    video_id, canonical = normalize_url(url)
+    runtime_root = Path(runtime_root).expanduser().resolve()
+    job = Path(output_root).expanduser().resolve() / video_id
+    work = job / '.work'
+    with a.job_lock(work):
+        manifest_path = work / 'manifest.json'
+        manifest = a.read_json(manifest_path) if manifest_path.exists() else {
+            'schema_version': 1, 'video_id': video_id, 'canonical_url': canonical,
+            'original_url': url, 'stage': 'acquiring', 'created_at': a.now(),
+            'quality_hints': [], 'completed_blocks': [], 'timings': {}}
+        manifest['runtime_root'] = str(Path(runtime_root).expanduser().resolve())
+        manifest['timeout_seconds'] = timeout_seconds
+        save(work, manifest)
+        try:
+            require_runtime(runtime_root)
+            source_path = work / 'source.json'
+            current_material = material_identity()
+            materials_valid = all(not manifest.get(key) or (path.exists() and a.digest(path) == manifest[key])
+                                  for key, path in [('metadata_sha256', work / 'metadata.json'),
+                                                    ('captions_sha256', work / 'captions.raw.json'),
+                                                    ('audio_sha256', Path(manifest.get('audio_path') or work / 'missing-audio'))])
+            incomplete = any(h.startswith('INCOMPLETE_GAP_CHECK:') for h in manifest['quality_hints'])
+            source_valid = (not incomplete and materials_valid and source_path.exists() and manifest.get('source_sha256') == a.digest(source_path)
+                            and manifest.get('material_identity') == current_material)
+            if source_valid:
+                a.validate_source(a.read_json(source_path))
+                same_review = manifest.get('prompt_version') == a.PROMPT_VERSION and manifest.get('contract_version') == a.CONTRACT_VERSION
+                complete = (manifest['stage'] == 'complete' and same_review and (job / 'reading.md').exists()
+                            and manifest.get('reading_sha256') == a.digest(job / 'reading.md'))
+                manifest.update(stage='complete' if complete else 'awaiting_ai', prompt_version=a.PROMPT_VERSION,
+                                contract_version=a.CONTRACT_VERSION)
+                manifest['chunks'] = a.chunk_source(source_path, work)
+                manifest['last_cache_hit_at'] = a.now()
+                manifest.pop('error', None)
+                manifest.pop('resume_from', None)
+                save(work, manifest)
+                return status(job, manifest, True)
+            manifest['stage'] = 'acquiring'
+            manifest['quality_hints'] = []
+            save(work, manifest)
+            adapter = adapter or r.NetworkAdapter(runtime_root, work)
+            info_path = work / 'metadata.json'
+            acquired_start = time.monotonic()
+            if info_path.exists() and manifest.get('metadata_sha256') == a.digest(info_path):
+                info = a.read_json(info_path)
+            else:
+                info = r.acquire_metadata(canonical, adapter)
+                if info.get('is_live') or not info.get('duration'):
+                    raise a.JobError('UNSUPPORTED_VIDEO', '不支持直播或时长未知的视频。')
+                a.write_json(info_path, info)
+                manifest['metadata_sha256'] = a.digest(info_path)
+                manifest['acquired_at'] = a.now()
+            language = info.get('language')
+            if not language:
+                # yt-dlp marks the original auto-caption language with an -orig track.
+                original = [k[:-5] for k in info.get('automatic_captions', {}) if k.endswith('-orig')]
+                language = original[0] if len(original) == 1 else None
+            manifest.update(title=info.get('title') or video_id, channel=info.get('channel') or info.get('uploader'),
+                            duration_ms=round(info['duration']*1000), source_language=language,
+                            tool_model_lock=r.LOCK, material_identity=current_material)
+            save(work, manifest)
+            captions_path = work / 'captions.raw.json'
+            if captions_path.exists() and manifest.get('captions_sha256') == a.digest(captions_path):
+                captions = a.read_json(captions_path)
+            else:
+                try:
+                    captions = adapter.transcripts(video_id, language)
+                except Exception as e:
+                    captions = {'tracks': [], 'segments': [], 'language': language, 'source_kind': None,
+                                'error': type(e).__name__}
+                    manifest['quality_hints'].append('CAPTIONS_UNAVAILABLE: ' + type(e).__name__)
+                a.write_json(captions_path, captions)
+                manifest['captions_sha256'] = a.digest(captions_path)
+                save(work, manifest)
+            if captions.get('error'):
+                manifest['quality_hints'].append('CAPTIONS_UNAVAILABLE: ' + captions['error'])
+            segments = []
+            for x in captions['segments']:
+                text = x['text'].strip()
+                if text and x['duration'] > 0:
+                    segments.append({'start_ms': round(x['start']*1000),
+                                     'end_ms': min(manifest['duration_ms'], round((x['start']+x['duration'])*1000)),
+                                     'text': text, 'language': captions['language'], 'source_kind': captions['source_kind']})
+            segments = sorted([x for x in segments if x['end_ms'] > x['start_ms']], key=lambda x: x['start_ms'])
+            if segments and (sum(len(x['text']) for x in segments)/max(1, info['duration']) > 80 or
+                             any('\ufffd' in x['text'] for x in segments)):
+                manifest['quality_hints'].append('CAPTIONS_DISTORTED')
+                segments = []
+            gaps = r.caption_gaps(segments, manifest['duration_ms'])
+            if gaps or not segments:
+                audio_path = Path(manifest['audio_path']) if manifest.get('audio_path') else None
+                try:
+                    if not audio_path or not audio_path.exists() or a.digest(audio_path) != manifest.get('audio_sha256'):
+                        audio_path = adapter.audio(canonical)
+                        manifest.update(audio_path=str(audio_path), audio_sha256=a.digest(audio_path))
+                        save(work, manifest)
+                    wav = r.convert_audio(audio_path, work)
+                    manifest['wav_sha256'] = a.digest(wav)
+                except Exception as e:
+                    if not segments:
+                        raise a.JobError('AUDIO_ACQUISITION_FAILED', '音频获取失败：' + type(e).__name__) from e
+                    manifest['quality_hints'].append('INCOMPLETE_GAP_CHECK: ' + type(e).__name__)
+                    wav = None
+                manifest['timings']['acquisition_seconds'] = round(time.monotonic()-acquired_start, 3)
+                if wav:
+                    manifest['stage'] = 'transcribing'
+                    save(work, manifest)
+                    def checkpoint(block, hit):
+                        row = {k: v for k, v in block.items() if k not in {'segments', 'boundary_candidates'}}
+                        row['cache_hit'] = hit
+                        manifest['completed_blocks'] = [b for b in manifest['completed_blocks']
+                                                        if (b['key'], b['core_start_ms']) != (row['key'], row['core_start_ms'])] + [row]
+                        save(work, manifest)
+                        print(json.dumps({'stage': 'transcribing', 'core_end_ms': row['core_end_ms'], 'cache_hit': hit}), file=sys.stderr, flush=True)
+                    options = {'runtime_root': runtime_root, 'language': (language or 'auto').split('-')[0],
+                               'timeout_seconds': timeout_seconds, 'on_chunk': checkpoint}
+                    started = time.monotonic()
+                    segments = (r.fill_gaps(segments, wav, work, options) if segments else
+                                r.transcribe_audio(wav, work / 'asr', options))
+                    manifest['timings']['asr_seconds'] = round(time.monotonic()-started, 3)
+            for i, s in enumerate(segments):
+                s['id'] = f's{i:06d}'
+            source = {'schema_version': 1, 'segments': segments}
+            a.validate_source(source)
+            a.write_json(source_path, source)
+            manifest.update(source_sha256=a.digest(source_path), stage='awaiting_ai',
+                            prompt_version=a.PROMPT_VERSION, contract_version=a.CONTRACT_VERSION)
+            manifest['chunks'] = a.chunk_source(source_path, work)
+            manifest['quality_hints'] = sorted(set(manifest['quality_hints']))
+            manifest.pop('error', None)
+            manifest.pop('resume_from', None)
+            save(work, manifest)
+            return status(job, manifest)
+        except Exception as e:
+            manifest.update(resume_from=manifest['stage'], stage='failed',
+                            error={'code': getattr(e, 'code', 'PROCESS_ERROR'), 'message': str(e)})
+            save(work, manifest)
+            raise
+
+
+def retranscribe(job, start_ms, end_ms):
+    work = job / '.work'
+    with a.job_lock(work):
+        manifest = a.read_json(work / 'manifest.json')
+        require_runtime(manifest['runtime_root'])
+        wav = work / 'audio.wav'
+        if not wav.exists() or a.digest(wav) != manifest.get('wav_sha256'):
+            raise a.JobError('AUDIO_MISSING', '重识别需要当前任务经过校验的音频。')
+        duration = r.audio_duration(wav)
+        if not 0 <= start_ms < end_ms <= duration or end_ms-start_ms > 50000:
+            raise a.JobError('RETRY_RANGE', '异常核心区间最多 50 秒；加前后 5 秒后最多 60 秒。')
+        start, end = max(0, start_ms-5000), min(duration, end_ms+5000)
+        record_id = f'retry-{start}-{end}'
+        path = work / 'retranscriptions' / (record_id + '.json')
+        if path.exists():
+            old = a.read_json(path)
+            if old.get('source_sha256') == manifest['source_sha256'] and old.get('audio_sha256') == manifest['wav_sha256']:
+                return {'status': 'candidate', 'path': str(path), 'cache_hit': True}
+        rows = r.transcribe_audio(wav, work / 'retranscriptions/audio',
+                                 {'runtime_root': manifest['runtime_root'], 'language': (manifest.get('source_language') or 'auto').split('-')[0],
+                                  'start_ms': start, 'end_ms': end, 'vad': False, 'context_ms': 0,
+                                  'timeout_seconds': manifest.get('timeout_seconds')})
+        a.write_json(path, {'schema_version': 1, 'id': record_id, 'start_ms': start, 'end_ms': end,
+                            'source_sha256': manifest['source_sha256'], 'audio_sha256': manifest['wav_sha256'],
+                            'segments': rows, 'created_at': a.now()})
+        return {'status': 'candidate', 'path': str(path), 'cache_hit': False}
+
+
+def finalize(job, review_path, guide_path):
+    work = job / '.work'
+    with a.job_lock(work):
+        manifest = a.read_json(work / 'manifest.json')
+        source_path = work / 'source.json'
+        if manifest.get('material_identity') and manifest['material_identity'] != material_identity():
+            raise a.JobError('SOURCE_VERSION', '材料处理版本已变化，请先 resume 再校对。')
+        if a.digest(source_path) != manifest.get('source_sha256'):
+            raise a.JobError('SOURCE_CHANGED', '来源已变化，请 resume 后重新校对。')
+        source, review = a.read_json(source_path), a.read_json(review_path)
+        guide = Path(guide_path).read_text(encoding='utf-8')
+        changes = a.validate_review(source, review, manifest, work)
+        article = a.render(manifest, source, review, guide)
+        # Validate everything before touching an earlier successful deliverable.
+        manifest['stage'] = 'finalizing'
+        save(work, manifest)
+        try:
+            a.write_json(work / 'review.json', review)
+            a.atomic_write(work / 'guide.txt', guide)
+            a.write_json(work / 'review-changes.json', changes)
+            a.atomic_write(job / 'reading.md', article)
+            manifest.update(stage='complete', reading_sha256=a.digest(job / 'reading.md'), completed_at=a.now(),
+                            prompt_version=a.PROMPT_VERSION, contract_version=a.CONTRACT_VERSION,
+                            needs_review=bool(manifest.get('quality_hints')) or any(x['action'] == 'uncertain' for x in review['segments']))
+            manifest.pop('error', None)
+            manifest.pop('resume_from', None)
+            save(work, manifest)
+            return status(job, manifest)
+        except OSError as e:
+            manifest.update(stage='failed', resume_from='finalizing',
+                            error={'code': 'FINALIZE_WRITE_FAILED', 'message': str(e)})
+            save(work, manifest)
+            raise a.JobError('FINALIZE_WRITE_FAILED', str(e)) from e
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest='command', required=True)
+    for name in ('doctor', 'setup', 'prepare'):
+        p = sub.add_parser(name)
+        p.add_argument('--runtime-root', type=Path, default=r.DEFAULT_ROOT)
+        if name == 'prepare':
+            p.add_argument('--url', required=True)
+            p.add_argument('--output-root', type=Path, default=Path.home() / 'Documents/YouTube阅读稿')
+            p.add_argument('--asr-timeout-seconds', type=float)
+    for name in ('resume', 'retranscribe', 'finalize'):
+        p = sub.add_parser(name)
+        p.add_argument('--job-dir', type=Path, required=True)
+        if name == 'retranscribe':
+            p.add_argument('--start-ms', type=int, required=True)
+            p.add_argument('--end-ms', type=int, required=True)
+        if name == 'finalize':
+            p.add_argument('--review', type=Path, required=True)
+            p.add_argument('--guide', type=Path, required=True)
+    args = parser.parse_args()
+    try:
+        if args.command == 'doctor':
+            result = r.doctor(args.runtime_root.expanduser().resolve())
+            print(json.dumps(result, ensure_ascii=False))
+            return 0 if result['ok'] else 1
+        if args.command == 'setup':
+            result = r.setup(args.runtime_root)
+        elif args.command == 'prepare':
+            result = prepare(args.url, args.output_root, args.runtime_root, args.asr_timeout_seconds)
+        else:
+            job = args.job_dir.expanduser().resolve()
+            if args.command == 'resume':
+                manifest = a.read_json(job / '.work/manifest.json')
+                result = prepare(manifest['canonical_url'], job.parent, manifest['runtime_root'], manifest.get('timeout_seconds'))
+            elif args.command == 'retranscribe':
+                result = retranscribe(job, args.start_ms, args.end_ms)
+            else:
+                result = finalize(job, args.review, args.guide)
+        print(json.dumps(result, ensure_ascii=False))
+        return 0
+    except (a.JobError, OSError, ValueError, KeyError, TypeError) as e:
+        print(json.dumps({'status': 'failed', 'error_code': getattr(e, 'code', 'INVALID_ARTIFACT'), 'message': str(e)}, ensure_ascii=False))
+        return 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())

package/payload/plugins/toolkit-release.json

@@ -0,0 +1 @@
+{"version":"0.2.0+codex.93e270581a3a47cddffbf5d5aba197b5b8ca33c78a0f1e3e3e8b7e3326f2bea6","digest":"93e270581a3a47cddffbf5d5aba197b5b8ca33c78a0f1e3e3e8b7e3326f2bea6"}

package/payload/pty-host/index.cjs

@@ -14763,6 +14763,8 @@ var CONFIGURATION_FIELDS = [
   { "path": "agents.companion.binary", "type": "string", "domain": "agents.companion", "sensitive": false, "remote": false, "apply": "restart", "description": "\u4F34\u968F\u7A97\u53E3 Agent \u53EF\u6267\u884C\u6587\u4EF6", "environmentKeys": ["RUNWEAVE_COMPANION_AGENT_EXECUTABLE"], "owner": "electron/companion", "scope": "instance", "storage": "settings.yaml", "default": { "rule": "\u4F7F\u7528\u5DF2\u5B89\u88C5 Codex App \u81EA\u5E26\u6267\u884C\u5165\u53E3\uFF1B\u663E\u5F0F\u503C\u5FC5\u987B\u53EF\u6267\u884C\u3002" }, "migrationSources": ["RUNWEAVE_COMPANION_AGENT_EXECUTABLE"] },
   { "path": "agents.codex.sessionsDirectory", "type": "string", "domain": "agents.codex", "sensitive": false, "remote": false, "apply": "restart", "description": "\u5916\u90E8 Codex \u4F1A\u8BDD\u76EE\u5F55\u5F15\u7528", "environmentKeys": ["RUNWEAVE_CODEX_SESSIONS_DIR"], "owner": "backend+app-server", "scope": "instance", "storage": "settings.yaml", "default": { "rule": "\u5916\u90E8\u5DE5\u5177\u62E5\u6709\u7684 CODEX_HOME/sessions \u6216\u64CD\u4F5C\u7CFB\u7EDF\u7528\u6237\u76EE\u5F55\u4E0B .codex/sessions\uFF0C\u4EC5\u5F15\u7528\u3002" }, "migrationSources": ["RUNWEAVE_CODEX_SESSIONS_DIR"] },
   { "path": "agents.traex.sessionsDirectory", "type": "string", "domain": "agents.traex", "sensitive": false, "remote": false, "apply": "restart", "description": "\u5916\u90E8 Trae \u4F1A\u8BDD\u76EE\u5F55\u5F15\u7528", "environmentKeys": ["RUNWEAVE_TRAE_SESSIONS_DIR"], "owner": "backend+app-server", "scope": "instance", "storage": "settings.yaml", "default": { "rule": "\u64CD\u4F5C\u7CFB\u7EDF\u7528\u6237\u76EE\u5F55\u4E0B .trae/cli/sessions\uFF0C\u4EC5\u5F15\u7528\u3002" }, "migrationSources": ["RUNWEAVE_TRAE_SESSIONS_DIR"] },
+  { "path": "terminal.defaultShell.command", "type": "string", "domain": "terminal.defaultShell", "sensitive": false, "remote": false, "apply": "reload", "description": "\u5F53\u524D\u7535\u8111\u65B0\u7EC8\u7AEF\u7684\u9ED8\u8BA4\u53EF\u6267\u884C\u6587\u4EF6\uFF1B\u7F3A\u7701\u4F7F\u7528\u7CFB\u7EDF Shell\uFF0C\u542F\u52A8\u4E0D\u53EF\u7528\u65F6\u56DE\u9000\u7CFB\u7EDF\u9ED8\u8BA4", "environmentKeys": [], "owner": "backend/terminal", "scope": "instance", "storage": "settings.yaml", "default": { "rule": "\u7CFB\u7EDF\u8D26\u6237\u767B\u5F55 Shell\uFF1BWindows \u4F7F\u7528 ComSpec\uFF1B\u4E0D\u53EF\u7528\u65F6\u91C7\u7528\u5E73\u53F0\u515C\u5E95" }, "migrationSources": ["new-field:no-legacy-source"] },
+  { "path": "terminal.defaultShell.args", "type": "array<string>", "domain": "terminal.defaultShell", "sensitive": false, "remote": false, "apply": "reload", "description": "\u9ED8\u8BA4 Shell \u7684\u542F\u52A8\u53C2\u6570\uFF1B\u7A7A\u6570\u7EC4\u660E\u786E\u4E0D\u52A0\u53C2\u6570\uFF0C\u7F3A\u7701\u4FDD\u7559 bash/zsh \u7684 -l \u884C\u4E3A", "environmentKeys": [], "owner": "backend/terminal", "scope": "instance", "storage": "settings.yaml", "default": { "rule": "\u6839\u636E\u6240\u9009\u7A0B\u5E8F\u89E3\u6790\uFF1Bbash/zsh \u4E3A [-l]\uFF0C\u5176\u4ED6\u4E3A\u7A7A\u6570\u7EC4" }, "migrationSources": ["new-field:no-legacy-source"] },
   { "path": "terminal.tmux.enabled", "type": "boolean", "domain": "terminal", "sensitive": false, "remote": false, "apply": "restart", "description": "tmux \u6301\u4E45\u7EC8\u7AEF\u5F00\u5173", "environmentKeys": ["TERMINAL_TMUX_ENABLED"], "owner": "backend/terminal", "scope": "instance", "storage": "settings.yaml", "default": { "value": true }, "migrationSources": ["TERMINAL_TMUX_ENABLED"] },
   { "path": "terminal.tmux.binary", "type": "string", "domain": "terminal", "sensitive": false, "remote": false, "apply": "restart", "description": "tmux \u53EF\u6267\u884C\u6587\u4EF6", "environmentKeys": ["TMUX_BINARY"], "owner": "backend/terminal", "scope": "instance", "storage": "settings.yaml", "default": { "value": "tmux" }, "migrationSources": ["TMUX_BINARY"] },
   { "path": "terminal.tmux.shutdownPolicy", "type": "string", "domain": "terminal", "sensitive": false, "remote": false, "apply": "restart", "description": "\u9000\u51FA\u65F6 tmux \u4FDD\u7559\u7B56\u7565", "environmentKeys": ["TERMINAL_TMUX_SHUTDOWN_POLICY"], "owner": "backend/terminal", "scope": "instance", "storage": "settings.yaml", "default": { "rule": "Stable \u4E3A preserve\uFF0CDev \u4E3A cleanup\u3002" }, "migrationSources": ["TERMINAL_TMUX_SHUTDOWN_POLICY"] },
@@ -19237,12 +19239,28 @@ var import_node_crypto6 = require("node:crypto");
 var import_node_module = require("node:module");
 var import_node_url = require("node:url");
 
+// packages/shared/src/terminal/shell.ts
+function terminalShellName(command) {
+  return (command.split(/[\\/]/).at(-1) ?? command).toLowerCase().replace(/\.exe$/, "");
+}
+function isInteractiveShellLaunch(launch2) {
+  const name = terminalShellName(launch2.command);
+  if (!["sh", "bash", "zsh", "dash", "ksh", "fish", "powershell", "pwsh", "cmd"].includes(name)) return false;
+  return !(launch2.args ?? []).some((arg) => {
+    const value = arg.toLowerCase();
+    if (name === "cmd") return !/^\/(?:d|q|a|u|e:(?:on|off)|f:(?:on|off)|v:(?:on|off))$/.test(value);
+    if (name === "powershell" || name === "pwsh") return !["-nologo", "-noprofile", "-noexit", "-login", "-l"].includes(value);
+    return ["--help", "--version"].includes(value) || !value.startsWith("-") || value === "--" || /^-[^-]*[cs]/.test(value) || /^--(?:command|init-command)(?:=|$)/.test(value);
+  });
+}
+
 // packages/pty-host/src/input-operations.ts
 var import_node_crypto4 = require("node:crypto");
 var InputOperations = class {
-  constructor(write, isRunning) {
+  constructor(write, isRunning, generation = () => 0) {
     this.write = write;
     this.isRunning = isRunning;
+    this.generation = generation;
   }
   operations = /* @__PURE__ */ new Map();
   sequences = /* @__PURE__ */ new Map();
@@ -19297,13 +19315,16 @@ var InputOperations = class {
     };
     this.operations.set(input.operationId, operation);
     this.sequences.set(input.sequence, input.operationId);
+    const acceptedGeneration = this.generation();
     operation.done = this.tail.then(async () => {
       try {
         for (const step of input.steps) {
+          if (acceptedGeneration !== this.generation()) throw new Error("HOST_PROCESS_CHANGED");
           if (!this.isRunning()) throw new Error("HOST_SESSION_GONE");
           if (step.type === "text") this.write(step.data);
           else await new Promise((resolve) => setTimeout(resolve, step.ms));
         }
+        if (acceptedGeneration !== this.generation()) throw new Error("HOST_PROCESS_CHANGED");
         operation.result.state = "written";
       } catch (error) {
         operation.result.state = "failed";
@@ -19744,17 +19765,9 @@ var TerminalOutputScreen = class _TerminalOutputScreen {
 // packages/pty-host/src/sessions.ts
 var requireNative = (0, import_node_module.createRequire)((0, import_node_url.fileURLToPath)(__IMPORT_META_URL__));
 var HostSession = class {
-  info;
-  buffer = new TerminalOutputRecoveryBuffer();
-  screen;
-  inputs;
-  createDigest;
-  outputListeners = /* @__PURE__ */ new Set();
-  exitListeners = /* @__PURE__ */ new Set();
-  resizeListeners = /* @__PURE__ */ new Set();
-  degraded = false;
-  terminal;
   constructor(hostInstanceId, options, prepareEnv) {
+    this.options = options;
+    this.prepareEnv = prepareEnv;
     this.createDigest = (0, import_node_crypto6.createHash)("sha256").update(JSON.stringify(options)).digest("hex");
     this.info = {
       hostInstanceId,
@@ -19772,28 +19785,75 @@ var HostSession = class {
       this.degraded = true;
     });
     this.screen.resize(options.cols, options.rows);
-    const pty = requireNative("node-pty");
+    this.inputs = new InputOperations((data) => this.terminal.write(data), () => this.info.status === "running", () => this.processGeneration);
     try {
-      this.terminal = pty.spawn(options.command, options.args, {
-        name: "xterm-256color",
-        cols: options.cols,
-        rows: options.rows,
-        cwd: options.cwd,
-        env: { ...options.env, ...prepareEnv(this.info.gatewayToken, this.info.terminalSessionId) }
-      });
+      this.spawn(options);
     } catch (error) {
-      this.screen.dispose();
-      throw error;
-    }
-    this.inputs = new InputOperations((data) => this.terminal.write(data), () => this.info.status === "running");
-    this.terminal.onData((data) => {
-      this.info.pid = this.terminal.pid;
-      for (const frame of this.buffer.append(data)) {
-        if (!this.degraded) this.screen.append(frame);
-        for (const listener of this.outputListeners) listener(frame);
+      try {
+        if (!this.activateFallback(String(error))) throw error;
+      } catch (fallbackError) {
+        this.screen.dispose();
+        throw fallbackError;
       }
+    }
+  }
+  info;
+  buffer = new TerminalOutputRecoveryBuffer();
+  screen;
+  inputs;
+  createDigest;
+  outputListeners = /* @__PURE__ */ new Set();
+  exitListeners = /* @__PURE__ */ new Set();
+  resizeListeners = /* @__PURE__ */ new Set();
+  launchListeners = /* @__PURE__ */ new Set();
+  degraded = false;
+  terminal;
+  fallbackActivated = false;
+  closing = false;
+  processGeneration = 0;
+  startupDeadline = 0;
+  emitOutput(data) {
+    for (const frame of this.buffer.append(data)) {
+      if (!this.degraded) this.screen.append(frame);
+      for (const listener of this.outputListeners) listener(frame);
+    }
+  }
+  activateFallback(reason) {
+    if (!this.options.fallback || this.fallbackActivated || this.closing || !isInteractiveShellLaunch(this.options)) return false;
+    this.fallbackActivated = true;
+    this.emitOutput("[Runweave: shell failed to start; using system default: " + this.options.fallback.command + "]\r\n");
+    this.spawn(this.options.fallback, reason);
+    return true;
+  }
+  spawn(launch2, fallbackReason) {
+    const pty = requireNative("node-pty");
+    const started = Date.now();
+    const terminal = pty.spawn(launch2.command, launch2.args, {
+      name: "xterm-256color",
+      cols: this.info.cols,
+      rows: this.info.rows,
+      cwd: this.options.cwd,
+      env: { ...launch2.env, ...this.prepareEnv(this.info.gatewayToken, this.info.terminalSessionId) }
     });
-    this.terminal.onExit((event) => {
+    this.startupDeadline = this.options.fallback && isInteractiveShellLaunch(this.options) ? Date.now() + 1e3 : 0;
+    this.processGeneration++;
+    this.terminal = terminal;
+    this.info.pid = terminal.pid;
+    this.info.launch = { command: launch2.command, args: [...launch2.args], ...fallbackReason ? { fallbackReason } : {} };
+    for (const listener of this.launchListeners) listener(this.info.launch);
+    terminal.onData((data) => {
+      if (this.terminal === terminal) this.emitOutput(data);
+    });
+    terminal.onExit((event) => {
+      if (this.terminal !== terminal) return;
+      if (event.exitCode > 0 && Date.now() - started < 1e3) {
+        try {
+          if (this.activateFallback(`Shell exited with code ${event.exitCode}`)) return;
+        } catch (error) {
+          this.emitOutput(`[Runweave: system shell failed to start: ${String(error)}]\r
+`);
+        }
+      }
       this.info.status = "exited";
       this.info.exitCode = event.exitCode;
       for (const listener of this.exitListeners) listener(event.exitCode);
@@ -19801,7 +19861,7 @@ var HostSession = class {
   }
   async ready() {
     const deadline = Date.now() + 1e4;
-    while (this.terminal.pid < 1 && this.info.status === "running" && Date.now() < deadline)
+    while ((this.terminal.pid < 1 || Date.now() < this.startupDeadline) && this.info.status === "running" && Date.now() < deadline)
       await new Promise((resolve) => setTimeout(resolve, 20));
     this.info.pid = this.terminal.pid;
     if (this.info.pid < 1) {
@@ -19828,6 +19888,7 @@ var HostSession = class {
   }
   signal(signal) {
     if (!["SIGINT", "SIGTERM", "SIGKILL"].includes(signal)) throw new Error("HOST_SIGNAL_INVALID");
+    this.closing = true;
     if (process.platform === "win32") {
       if (signal === "SIGINT") this.terminal.write("");
       else this.close();
@@ -19835,6 +19896,7 @@ var HostSession = class {
   }
   close() {
     if (this.info.status !== "running") return;
+    this.closing = true;
     this.terminal.kill();
   }
   snapshot() {
@@ -19891,7 +19953,8 @@ var createSchema = external_exports.object({
   cwd: external_exports.string().min(1),
   cols: external_exports.number().int().min(2).max(500),
   rows: external_exports.number().int().min(1).max(200),
-  env: external_exports.record(external_exports.string().optional())
+  env: external_exports.record(external_exports.string().optional()),
+  fallback: external_exports.object({ command: external_exports.string().min(1).max(32768), args: external_exports.array(external_exports.string()).max(256), env: external_exports.record(external_exports.string().optional()) }).optional()
 });
 var wireSchema = external_exports.object({ requestId: external_exports.string().uuid(), token: external_exports.string(), hostInstanceId: external_exports.string().uuid(), action: external_exports.string(), body: external_exports.unknown() });
 async function startHost(scope, release) {
@@ -20061,10 +20124,15 @@ async function startHost(scope, release) {
           const resized = (cols, rows) => {
             if (ready) sendJson(socket, { type: "resize", terminalSessionId: session.info.terminalSessionId, cols, rows, cursor: session.buffer.cursor });
           };
+          const launched = (launch2) => {
+            if (ready) sendJson(socket, { type: "launch", terminalSessionId: session.info.terminalSessionId, launch: launch2 });
+          };
+          session.launchListeners.add(launched);
           session.outputListeners.add(output);
           session.exitListeners.add(exited);
           session.resizeListeners.add(resized);
           subscriptions.set(session.info.terminalSessionId, () => {
+            session.launchListeners.delete(launched);
             session.outputListeners.delete(output);
             session.exitListeners.delete(exited);
             session.resizeListeners.delete(resized);

package/payload/scripts/toolkit/codex-state.mjs

@@ -0,0 +1,75 @@
+import { existsSync, realpathSync } from "node:fs";
+import path from "node:path";
+import { commandExists, runResult } from "./sync-runtime.mjs";
+import { packageMatches } from "./release.mjs";
+
+export function codexReleaseInstalled(release, { marketplaceName, pluginName, publishRoot, cacheRoot }) {
+  if (!commandExists("codex")) return false;
+  const result = runResult("codex", [
+    "plugin",
+    "list",
+    "--marketplace",
+    marketplaceName,
+    "--json",
+  ]);
+  if (result.status !== 0) return false;
+  const installed = JSON.parse(result.stdout).installed?.find(
+    (plugin) => plugin.pluginId === `${pluginName}@${marketplaceName}`,
+  );
+  return (
+    installed?.version === release.version &&
+    sameDirectory(installed?.marketplaceSource?.source, publishRoot) &&
+    packageMatches(
+      path.join(
+        cacheRoot,
+        release.version,
+      ),
+      release.files,
+    )
+  );
+}
+
+function sameDirectory(left, right) {
+  return typeof left === "string" && (
+    left === right || existsSync(left) && existsSync(right) && realpathSync(left) === realpathSync(right)
+  );
+}
+
+export function collectSessionReferencedCodexVersions(pluginName, marketplaceName, codexHome) {
+  if (!commandExists("rg")) {
+    return [];
+  }
+
+  const sessionsDir = path.join(codexHome, "sessions");
+  if (!existsSync(sessionsDir)) {
+    return [];
+  }
+
+  const pattern = [
+    "plugins/cache",
+    marketplaceName,
+    pluginName,
+    "[0-9]+\\.[0-9]+\\.[0-9]+\\+codex\\.[a-f0-9]+",
+  ].join("/");
+  const result = runResult(
+    "rg",
+    [
+      "--only-matching",
+      "--no-filename",
+      "--color",
+      "never",
+      pattern,
+      sessionsDir,
+    ],
+    { quiet: true },
+  );
+  if (result.status !== 0 && result.status !== 1) {
+    return [];
+  }
+
+  const versionPattern = /[0-9]+\.[0-9]+\.[0-9]+\+codex\.[a-f0-9]+/g;
+  return Array.from(
+    new Set(`${result.stdout || ""}`.match(versionPattern) ?? []),
+  );
+}
+