P0-P8: Full V1.0.0 Alpha implementation + audit reports

Implements 123 tasks across 9 phases (T-001..T-809) totaling 146 source files.

Monorepo (P0):
- 7-package Bun + Turborepo + TypeScript monorepo
- dependency-cruiser enforcing 7 forbidden edges + 5 deep-import rules

Contracts (P0):
- 16 type files (ids/error/event/runtime/ipc/task/worker-result/tool/artifact/evidence/project/provider/permission/ui/capability/platform)

Storage & Events (P1):
- DatabaseManager + MigrationRunner (19 tables, 22 indexes, 5 schema_meta seeds)
- 16 repositories (Repository<T,I,U> pattern, INV-1 status columns via EventStore.project only)
- EventSchemaRegistry (54 durable + 7 ephemeral), EventStore, EventBus, EventIngestor
- Project/Session/Artifact/Evidence stores + 8-step Recovery

Tools & Permission (P2):
- PathClassifier (8 categories), CommandRiskAnalyzer (10 categories), SecretRedactor
- PermissionEngine 6-layer evaluation (capability→profile→task_scope→risk→credential→user_prompt)
- ToolRegistry with 20+ tools across fs/shell/git/project/artifact/context/permission/doctor
- CapabilityManifestValidator + CapabilityRegistry

LLM & Context (P3):
- ModelConfigLoader, CapabilityMatrix, AnthropicCanonicalConverter
- AnthropicAdapter + OpenAICompatibleAdapter
- ProviderManager facade
- PromptLayerLoader (L0/L1/L3/L5), CompactionPolicy, ContextAssembler

Worker IPC & Scheduler (P4):
- WorkerProtocol (NDJSON), WorkerProcess (exit codes 0-5), WorkerManager (spawn/handshake)
- WorkerRuntime (INV-3: IPC only, no direct fs/shell/SQLite)
- 5 worker roles (Executor/Reviewer/Debugger/Compactor/ExperienceMiner)
- TaskGraph, WavePlanner, RetryPlanner, AgentMonitor, WorkspaceManager
- Scheduler (state machine), 8-step Recovery

C++ Toolchain (P5):
- DiagnosticParser, CppProjectDetector, CMakeConfigurator, CppBuilder
- CppTestRunner, CppcheckRunner, ClangdClient
- CppToolRegistrar + capability manifest

Projection & TUI (P6):
- ProjectionStore (hydrate/apply/snapshot/subscribe)
- TuiApp + 8 components (Session/Task/Agent/Tool/Diff/Evidence/Permission/Blocker/Hud)
- ProjectionClient in-process ref

Agents & Knowledge (P7):
- MainAgent, ArchitectureDesigner
- DebugKnowledgeStore + LearnedMemoryStore (single-writer, outbox model)
- Role integration wiring

CLI & Doctor & Release (P8):
- Logger + DeveloperLogEncryptor (AES-256-GCM)
- DoctorService (self_bootstrap first)
- RuntimeApp + ServiceRegistry
- 11 CLI commands: run/init/doctor/provider/resume/compact/history/session/restore/e2e/release
- CliEntrypoint + air<TODO>

Audit (in AirPlan/docs/):
- Deepseek开发阶段审计.md (97 findings)
- Opus开发阶段审计.md (140+ findings, 18 P0 blockers)
- MiniMaxM3开发阶段审计.md (18 P0 blockers, focuses on executability)
- AirPlan/TODO.md (technical debt + 42 TODOs by phase)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
AirCoding
2026-06-02 19:19:55 +08:00
parent 071283df8f
commit a773bac28c
179 changed files with 21855 additions and 0 deletions

View File

@@ -0,0 +1,147 @@
/**
* WorkerProcess - Owns NDJSON pipe for a Bun child process
*
* Implements DD §8.1. stdout=protocol, stderr=fatal/log; exit-code table 05.
*
* @module packages/runtime/src/workers/WorkerProcess
*/
import type { ChildProcess } from 'child_process'
import { WorkerProtocol, type WorkerMessage, type WorkerMessageType, type WorkerMessageDirection } from './WorkerProtocol.js'
export type WorkerExitCode =
| 0 // Normal exit
| 1 // Error (unrecoverable)
| 2 // Protocol error
| 3 // Permission denied
| 4 // Task blocked (needs intervention)
| 5 // Timeout
interface ExitCodeInfo {
semantic: string
description: string
}
const EXIT_CODE_TABLE: Record<WorkerExitCode, ExitCodeInfo> = {
0: { semantic: 'normal', description: 'Worker completed successfully' },
1: { semantic: 'error', description: 'Unrecoverable error occurred' },
2: { semantic: 'protocol_error', description: 'Protocol violation or deserialization failure' },
3: { semantic: 'permission_denied', description: 'Worker denied permission for operation' },
4: { semantic: 'blocked', description: 'Task blocked, needs intervention' },
5: { semantic: 'timeout', description: 'Worker exceeded time limit' }
}
export class WorkerProcess {
private proc: ChildProcess | null = null
private protocol: WorkerProtocol
private message_handlers: Map<string, (msg: WorkerMessage) => void> = new Map()
private buffer: string = ''
constructor() {
this.protocol = new WorkerProtocol()
}
/**
* Set the child process.
*/
set_process(proc: ChildProcess): void {
this.proc = proc
this.setup_streams()
}
/**
* Send a message to the worker process.
*/
send(message: WorkerMessage): void {
if (!this.proc?.stdin?.writable) {
throw new Error('Worker process stdin is not writable')
}
const line = this.protocol.encode(message)
this.proc.stdin.write(line)
}
/**
* Register a message handler.
*/
on_message(type: WorkerMessageType, handler: (msg: WorkerMessage) => void): void {
this.message_handlers.set(type, handler)
}
/**
* Get exit code info.
*/
get_exit_code_info(code: number): ExitCodeInfo | undefined {
return EXIT_CODE_TABLE[code as WorkerExitCode]
}
/**
* Check if process is alive.
*/
is_alive(): boolean {
if (!this.proc) return false
return this.proc.exitCode === null
}
/**
* Kill the worker process.
*/
kill(signal: NodeJS.Signals = 'SIGTERM'): boolean {
return this.proc?.kill(signal) || false
}
/**
* Get the process ID.
*/
get_pid(): number | undefined {
return this.proc?.pid
}
// ============================================================================
// Private
// ============================================================================
private setup_streams(): void {
if (!this.proc) return
// stdout = protocol channel
if (this.proc.stdout) {
this.proc.stdout.on('data', (data: Buffer) => {
this.buffer += data.toString()
this.process_buffer()
})
}
// stderr = log/fatal
if (this.proc.stderr) {
this.proc.stderr.on('data', (data: Buffer) => {
const message = data.toString().trim()
if (message) {
console.error('[Worker stderr]', message)
}
})
}
// Exit handler
this.proc.on('exit', (code, signal) => {
const info = this.get_exit_code_info(code || 1)
console.log(`[Worker] exited with code ${code} (${info?.semantic || 'unknown'}): ${info?.description || ''}`)
})
}
private process_buffer(): void {
const lines = this.buffer.split('\n')
this.buffer = lines.pop() || ''
for (const line of lines) {
const message = this.protocol.decode(line)
if (!message) continue
// Route to handler
const handler = this.message_handlers.get(message.type)
if (handler) {
handler(message)
}
}
}
}