@sireai/optimus 0.1.1

package/dist/types.d.ts

@@ -0,0 +1,629 @@
+export type TaskSource = "polling" | "manual" | "api" | "system";
+export type RuntimeEventProcessingStatus = "received" | "triaging" | "accepted" | "rejected" | "failed";
+export type TriageDecisionType = "accepted" | "rejected";
+export type TaskRunStatus = "created" | "leased" | "bootstrapping" | "sdk_starting" | "sdk_running" | "sdk_streaming" | "validating" | "completed" | "failed" | "timed_out" | "cancel_requested" | "canceled" | "recovered";
+export type TaskRunHealth = "waiting_start" | "healthy_running" | "slow_running" | "suspected_stall" | "completed" | "failed" | "timed_out" | "cancel_requested" | "canceled" | "recovered";
+export type TaskStatus = "queued" | "preparing" | "running" | "patch_generated" | "validating" | "completed" | "needs_human" | "failed" | "canceled";
+export type Severity = "low" | "medium" | "high";
+export type FailureCategory = "timeout" | "process_exit" | "parse_error" | "schema_error" | "config_error" | "network_error" | "provider_error" | "environment_error" | "input_missing" | "auth_missing" | "unknown";
+export type CodexApprovalPolicy = "never" | "on-request" | "on-failure" | "untrusted";
+export type CodexSandboxMode = "read-only" | "workspace-write" | "danger-full-access";
+export type CodexReasoningEffort = "minimal" | "low" | "medium" | "high" | "xhigh";
+export type CodexAuthMode = "openai_api_key" | "codex_cli_login" | "model_provider";
+export type SelfUpdateMode = "off" | "notify" | "auto";
+export type SelfUpdateStartupCommand = "start" | "submit";
+export type CodexWireApi = "responses" | "chat";
+export type CodexConfigValue = string | number | boolean | CodexConfigValue[] | {
+    [key: string]: CodexConfigValue;
+};
+export interface CodexAuthDiagnostics {
+    mode: CodexAuthMode;
+    authenticated: boolean;
+    source: "config" | "env" | "cli_login" | "unknown";
+    apiKeyEnvName?: string;
+    requiredEnvVars: string[];
+    presentEnvVars: string[];
+    missingEnvVars: string[];
+    baseUrl?: string;
+    verification: "static" | "runtime_required";
+    providerId?: string;
+    providerDisplayName?: string;
+}
+export interface CodexPreflightCheck {
+    name: string;
+    ok: boolean;
+    detail: string;
+    failureCategory?: FailureCategory;
+}
+export interface CodexConnectivityCheck {
+    name: "sandbox_network" | "codex_auxiliary_connectivity" | "provider_connectivity";
+    ok: boolean;
+    detail: string;
+    host?: string;
+    failureCategory?: FailureCategory;
+}
+export interface CodexPreflightReport {
+    ok: boolean;
+    summary: string;
+    auth: CodexAuthDiagnostics;
+    checks: CodexPreflightCheck[];
+    resolvedModel?: string;
+    resolvedProvider?: string;
+    failureCategory?: FailureCategory;
+}
+export interface CodexHealthCheckResult {
+    ok: boolean;
+    summary: string;
+    diagnostics: {
+        model?: string;
+        provider?: string;
+        codexHomeDir: string;
+        timeoutMs: number;
+        approvalPolicy: CodexApprovalPolicy;
+        sandboxMode: CodexSandboxMode;
+        failureCategory?: FailureCategory;
+        auth?: CodexAuthDiagnostics;
+        preflightChecks?: CodexPreflightCheck[];
+        connectivityChecks?: CodexConnectivityCheck[];
+    };
+    rawOutput?: string;
+}
+export interface EvolutionSkillSummary {
+    taskType: string;
+    createdSkillIds: string[];
+    updatedSkillIds: string[];
+    violations: string[];
+}
+export interface ObservationHint {
+    area: string;
+    signal: string;
+    reason: string;
+    suggestedAction: string;
+}
+export interface RuntimeEventContent {
+    source: TaskSource;
+    sourceRef?: string;
+    sourceRecordId?: string;
+    contentFingerprint?: string;
+    title?: string;
+    description?: string;
+    content: string;
+    repo?: string;
+    branch?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface FeishuAssigneeIdentity {
+    displayName?: string;
+    login?: string;
+    email?: string;
+    openId?: string;
+    resolvedBy?: string;
+}
+export interface PollingCheckpoint {
+    cursor?: string;
+    lastSourceRecordId?: string;
+    observedAt?: string;
+    acceptedCount?: number;
+    duplicateCount?: number;
+    updatedCount?: number;
+    skippedCount?: number;
+}
+export type RepositoryExecutionMode = "copy" | "inplace";
+export interface RepositoryRoot {
+    path: string;
+    alias?: string;
+    executionMode: RepositoryExecutionMode;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface PollingSourceAutomationConfig {
+    enabled: boolean;
+    taskTypeHint?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface PollingIntakeSourceConfig {
+    id: string;
+    type: "noop" | "sample_file" | "json_file";
+    enabled: boolean;
+    intervalMs?: number;
+    sampleFile?: string;
+    jsonFile?: string;
+    removeAfterRead?: boolean;
+    eventType?: Extract<RuntimeEventType, "problem.discovered" | "bug.discovered">;
+    defaultRepo?: string;
+    automation?: PollingSourceAutomationConfig;
+}
+export interface SourceRecord {
+    pollerId: string;
+    sourceRecordId: string;
+    contentFingerprint: string;
+    eventType: Extract<RuntimeEventType, "problem.discovered" | "bug.discovered">;
+    content: RuntimeEventContent;
+}
+export interface PollingEnqueueResult {
+    pollerId: string;
+    acceptedCount: number;
+    duplicateCount: number;
+    updatedCount: number;
+    skippedCount: number;
+    checkpoint?: PollingCheckpoint;
+}
+export type PollerStatus = "idle" | "running" | "backoff" | "failed" | "disabled";
+export interface PollerStateSnapshot {
+    pollerId: string;
+    pollerType: PollingIntakeSourceConfig["type"];
+    enabled: boolean;
+    eventType: Extract<RuntimeEventType, "problem.discovered" | "bug.discovered">;
+    pollingIntervalMs: number;
+    status: PollerStatus;
+    lastPolledAt?: string;
+    lastSucceededAt?: string;
+    lastFailedAt?: string;
+    failureCount: number;
+    lastError?: string;
+    nextPollAt?: string;
+    lastAcceptedCount: number;
+    lastDuplicateCount: number;
+    lastUpdatedCount: number;
+    lastSkippedCount: number;
+    checkpoint?: PollingCheckpoint;
+    sourceRecordCount: number;
+}
+export type RuntimeEventType = "task.submitted_manually" | "problem.discovered" | "bug.discovered" | "task.retry_requested" | "task.cancel_requested";
+export interface RuntimeEvent {
+    eventId: string;
+    type: RuntimeEventType;
+    content: RuntimeEventContent;
+    createdAt: string;
+    processedAt?: string;
+}
+export interface TriageDecisionAccepted {
+    decision: "accepted";
+    summary: string;
+    taskType: string;
+    taskPackage: TaskPackage;
+}
+export interface TriageDecisionRejected {
+    decision: "rejected";
+    summary: string;
+    reason: string;
+    missingInfo?: string[];
+}
+export type TriageDecision = TriageDecisionAccepted | TriageDecisionRejected;
+export type TaskArtifactKind = "result_md" | "patch_diff" | "publication_plan" | "verification" | "review_packet" | "log" | "attachment";
+export interface TaskArtifact {
+    kind?: TaskArtifactKind;
+    path: string;
+    createdAt: string;
+}
+export type DeliveryOutcome = "analysis_only" | "repair_candidate" | "verified_fix" | "canceled" | "failed";
+export type TaskPublicationReviewSystemType = "gerrit" | "github" | "unknown" | "mixed";
+export type TaskPublicationReviewStrategy = "gerrit_change" | "github_pr" | "manual";
+export interface TaskPublicationReviewSystem {
+    type: TaskPublicationReviewSystemType;
+    strategy: TaskPublicationReviewStrategy;
+    remoteName?: string;
+    remoteUrl?: string;
+    host?: string;
+    repository?: string;
+}
+export interface TaskPublicationProjectState {
+    projectName?: string;
+    projectPath: string;
+    upstreamRemote?: string;
+    upstreamBranch?: string;
+    manifestRevision?: string;
+    targetBranch?: string;
+    targetSource?: "upstream" | "manifest_revision";
+    reviewSystem?: TaskPublicationReviewSystem;
+}
+export interface TaskPublicationGitState {
+    workspaceKind?: "git_root" | "repo_managed" | "plain_directory";
+    repoDir?: string;
+    branch?: string;
+    upstreamRemote?: string;
+    upstreamBranch?: string;
+    manifestRevision?: string;
+    targetBranch?: string;
+    targetSource?: "upstream" | "manifest_revision";
+    reviewSystem?: TaskPublicationReviewSystem;
+    repoProjects?: TaskPublicationProjectState[];
+    unresolvedPaths?: string[];
+    headCommit?: string;
+    cleanWorkingTree?: boolean;
+}
+export interface TaskPublicationStatus {
+    applicable: boolean;
+    repoBound: boolean;
+    hasPatch: boolean;
+    action: "none" | "ready_for_publish" | "published";
+    reason?: string;
+    git?: TaskPublicationGitState;
+}
+export interface TaskDeliveryBundle {
+    taskId: string;
+    runId?: string;
+    taskType: string;
+    outcome: DeliveryOutcome;
+    createdAt: string;
+    summary: {
+        title: string;
+        repo?: string;
+        sourceRef?: string;
+        sourceUrl?: string;
+        qAssignee?: FeishuAssigneeIdentity;
+        decision: string;
+        failureLog?: string;
+        validation?: string;
+        rootCauseConclusion?: string;
+        analysisSummary?: string;
+        keyEvidence?: string;
+        recommendedAction?: string;
+        analysisDocUrl?: string;
+        risk?: string;
+        nextAction?: string;
+    };
+    warnings?: string[];
+    artifacts: {
+        resultMd?: string;
+        patchDiff?: string;
+        extras: string[];
+    };
+    publication?: TaskPublicationStatus;
+}
+export type DeliveryChannel = "console" | "feishu";
+export type TaskDeliveryAttemptStatus = "dispatched" | "skipped" | "failed";
+export interface TaskDeliveryAttempt {
+    taskId: string;
+    runId?: string;
+    channel: DeliveryChannel;
+    status: TaskDeliveryAttemptStatus;
+    summary: string;
+    createdAt: string;
+    deliveredAt?: string;
+    error?: string;
+}
+export type TaskPublicationAttemptMode = "dry_run" | "review_submit";
+export type TaskPublicationAttemptStatus = "planned" | "submitted" | "partial" | "skipped" | "failed";
+export interface TaskPublicationAttempt {
+    taskId: string;
+    runId?: string;
+    mode: TaskPublicationAttemptMode;
+    status: TaskPublicationAttemptStatus;
+    summary: string;
+    createdAt: string;
+    artifactPath?: string;
+    topic?: string;
+    topicUrl?: string;
+    reviewUrl?: string;
+    reviewUrls?: string[];
+    changeId?: string;
+    changeIds?: string[];
+    error?: string;
+}
+export interface TaskPackage {
+    taskPackageId: string;
+    sourceEventId: string;
+    source: TaskSource;
+    sourceRef?: string;
+    idempotencyKey?: string;
+    taskType: string;
+    title: string;
+    repo?: string;
+    branch?: string;
+    input: {
+        description?: string;
+        content: string;
+        metadata?: Record<string, unknown>;
+    };
+    createdAt: string;
+}
+export interface OrchestratorTask {
+    taskId: string;
+    taskPackageId: string;
+    sourceEventId: string;
+    taskType: string;
+    title: string;
+    status: TaskStatus;
+    riskLevel: Severity;
+    createdAt: string;
+    updatedAt: string;
+    activeRunId?: string;
+    runCount?: number;
+    abortSignal?: AbortSignal;
+}
+export interface TaskEvent {
+    taskId: string;
+    type: string;
+    detail: string;
+    createdAt: string;
+    runId?: string;
+    sourceEventId?: string;
+}
+export interface TaskRun {
+    runId: string;
+    taskId: string;
+    taskPackageId: string;
+    sourceEventId?: string;
+    status: TaskRunStatus;
+    taskStatus: TaskStatus;
+    health?: TaskRunHealth;
+    startedAt: string;
+    endedAt?: string;
+    summary?: string;
+    failureCategory?: FailureCategory;
+    addresses?: {
+        workspaceDir?: string;
+        visibleRepoDir?: string;
+        configuredExecutionMode?: RepositoryExecutionMode;
+        resolvedExecutionMode?: RepositoryExecutionMode;
+    };
+    sandboxMode?: CodexSandboxMode;
+    approvalPolicy?: CodexApprovalPolicy;
+    sdkThreadId?: string;
+    workspaceSkillMountDir?: string;
+    mountedSkills?: WorkspaceSkillMount[];
+    lastEventAt?: string;
+    lastEventType?: string;
+    heartbeatAt?: string;
+    progressCounter?: number;
+    commandCount?: number;
+    fileChangeCount?: number;
+    lastAgentMessagePreview?: string;
+    cancelRequestedAt?: string;
+    cancelRequestSourceEventId?: string;
+}
+export interface PanelEvent {
+    at: string;
+    scope: "runtime" | "triage" | "task" | "runner" | "repo" | "alert";
+    level: "info" | "warn" | "error";
+    headline: string;
+    detail?: string;
+    taskId?: string;
+    runId?: string;
+}
+export interface RuntimePanelTaskSnapshot {
+    taskId: string;
+    runId?: string;
+    taskType: string;
+    status: TaskStatus;
+    phase: TaskRunStatus | TaskStatus;
+    health?: TaskRunHealth;
+    repo?: string;
+    lastHeadline: string;
+    currentAction?: string;
+    elapsedMs: number;
+    idleMs: number;
+    artifacts: string[];
+}
+export interface RuntimePanelState {
+    runtime: {
+        running: boolean;
+        queueDepth: number;
+        activeWorkers: number;
+        activeRuns: number;
+        stalledRuns: number;
+        triageStatus: string;
+        uptimeMs: number;
+        databasePath?: string;
+        lastEventAt?: string;
+    };
+    activeTasks: RuntimePanelTaskSnapshot[];
+    recentEvents: PanelEvent[];
+    alerts: PanelEvent[];
+}
+export interface ResolvedHarnessDocument {
+    fileName: string;
+    title: string;
+    content: string;
+}
+export interface ResolvedHarness {
+    taskType: string;
+    roleDocument: ResolvedHarnessDocument;
+    constraintsDocument: ResolvedHarnessDocument;
+    contextDocument: ResolvedHarnessDocument;
+    standardDocument: ResolvedHarnessDocument;
+    evolutionDocument: ResolvedHarnessDocument;
+}
+export interface TaskExecutionRequest {
+    task: OrchestratorTask;
+    taskPackage: TaskPackage;
+    harness: ResolvedHarness;
+}
+export interface TaskExecutionDiagnostics {
+    usedFallback?: boolean;
+    fallbackReason?: string;
+    failureCategory?: FailureCategory;
+    sdkThreadId?: string;
+}
+export interface TaskExecutionError {
+    category: FailureCategory;
+    message: string;
+}
+export interface TaskResult {
+    status: "completed" | "failed";
+    error?: TaskExecutionError;
+    resultPath?: string;
+    diagnostics?: TaskExecutionDiagnostics;
+}
+export type TaskExecutionResult = TaskResult;
+export interface TaskStatusUpdate {
+    status: TaskStatus;
+    detail: string;
+    runStatus?: TaskRunStatus;
+    health?: TaskRunHealth;
+    eventType?: string;
+    sdkThreadId?: string;
+    agentMessagePreview?: string;
+    incrementProgressCounter?: boolean;
+    incrementCommandCount?: boolean;
+    incrementFileChangeCount?: boolean;
+    heartbeatAt?: string;
+}
+export type BuiltinSkillLevel = "shared" | "task";
+export type SkillSourceKind = "embedded" | "evolution";
+export interface InstalledBuiltinSkill {
+    id: string;
+    level: BuiltinSkillLevel;
+    sourceKind: SkillSourceKind;
+    version: string;
+    taskTypes: string[];
+    sourceDir: string;
+    storeDir: string;
+    mountName: string;
+    contentHash: string;
+}
+export interface WorkspaceSkillMount {
+    id: string;
+    level: BuiltinSkillLevel;
+    sourceKind: SkillSourceKind;
+    version: string;
+    taskTypes: string[];
+    sourceDir: string;
+    targetDir: string;
+    mountName: string;
+}
+export interface RepositoryMemoryContext {
+    taskType: string;
+    repoAlias: string;
+    memoryDir: string;
+    memoryFilePath: string;
+    metaFilePath: string;
+    exists: boolean;
+    content?: string;
+    baselineContentHash?: string;
+}
+export interface TaskExecutionContext {
+    taskRootDir: string;
+    addresses: import("./task-environment/execution-addresses.js").ExecutionAddresses;
+    sandboxMode: CodexSandboxMode;
+    approvalPolicy: CodexApprovalPolicy;
+    configuredExecutionMode?: RepositoryExecutionMode;
+    cleanupRequired?: boolean;
+    workspaceSkillMountDir?: string;
+    mountedSkills?: WorkspaceSkillMount[];
+    repoMemory?: RepositoryMemoryContext;
+    allowedEvolutionSkillDir?: string;
+    cleanup?: () => Promise<void>;
+    abortSignal?: AbortSignal;
+    onStatusUpdate?: (update: TaskStatusUpdate) => Promise<void> | void;
+}
+export interface OptimusConfig {
+    intake: {
+        pollingEnabled: boolean;
+        pollingIntervalMs: number;
+        pollingProvider: "noop" | "sample_file" | "json_file";
+        pollingSampleFile?: string;
+        pollingSources?: PollingIntakeSourceConfig[];
+        cliWatchEnabled: boolean;
+        cliInboxDir: string;
+        cliSignalWatchIntervalMs: number;
+    };
+    runtime: {
+        workerConcurrency: number;
+        startupTimeoutMs: number;
+        idleTimeoutMs: number;
+        stallWarningMs: number;
+        runTimeoutMs: number;
+        repoRoots: string[];
+        taskHarnessRootDir: string;
+        networkAccessEnabled: boolean;
+    };
+    storage: {
+        rootDir: string;
+    };
+    observability: {
+        enabled: boolean;
+        mode: "debug" | "release";
+        consoleLevel: "error" | "warn" | "info" | "debug";
+        fileLevel: "error" | "warn" | "info" | "debug";
+        healthLogIntervalMs: number;
+        logEmptyPolls: boolean;
+        retentionDays: number;
+        repeatFallbackCooldownMs: number;
+        maxRecentTasksInHealthLog: number;
+        soundEnabled: boolean;
+        soundTheme: {
+            taskStarted: string;
+            taskCompleted: string;
+            taskFailed: string;
+        };
+    };
+    jira: {
+        enabled: boolean;
+        baseUrl: string;
+        mcpUrl?: string;
+        authType: "http_headers" | "bearer" | "basic";
+        httpHeaders: Record<string, string>;
+        bearerToken?: string;
+        username?: string;
+        apiToken?: string;
+        password?: string;
+    };
+    codex: {
+        homeDir: string;
+        model?: string;
+        reasoningEffort: CodexReasoningEffort;
+        approvalPolicy: CodexApprovalPolicy;
+        sandboxMode: CodexSandboxMode;
+        auth: {
+            mode: CodexAuthMode;
+        };
+        provider?: {
+            id: string;
+            displayName: string;
+            baseUrl: string;
+            apiKeyEnvName: string;
+            wireApi: CodexWireApi;
+        };
+        apiKey?: string;
+        baseUrl?: string;
+    };
+    skills: {
+        embeddedRootDir: string;
+        evolutionRootDir: string;
+        storeDir: string;
+        sharedEnabled: boolean;
+        taskLevelEnabled: boolean;
+        disabledSkills: string[];
+    };
+    memory: {
+        rootDir: string;
+    };
+    delivery: {
+        enabled: boolean;
+        channels: Array<"console" | "feishu">;
+        summaryStyle: "dense";
+        feishu: {
+            format: "text" | "card";
+            webhook?: string;
+            webhooks?: string[];
+            secret?: string;
+            userMappings?: Record<string, {
+                openId: string;
+                displayName?: string;
+                email?: string;
+            }>;
+        };
+        retry: {
+            enabled: boolean;
+            maxAttempts: number;
+            backoffMs: number;
+            backgroundEnabled: boolean;
+            backgroundCooldownMs: number;
+            backgroundScanLimit: number;
+        };
+    };
+    publication: {
+        enabled: boolean;
+        dryRun: boolean;
+        reviewMode: "auto" | "gerrit" | "github" | "manual";
+    };
+    selfUpdate: {
+        enabled: boolean;
+        mode: SelfUpdateMode;
+        checkIntervalHours: number;
+        startupCommands: SelfUpdateStartupCommand[];
+    };
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/embedded-skills/shared/repo-inspection/SKILL.md

@@ -0,0 +1,9 @@
+# Repo Inspection
+
+Use this skill when the task requires quickly understanding repository layout, module boundaries, entrypoints, or key build and test commands before making changes.
+
+## Workflow
+- Read the task package first and identify the suspected repository area.
+- Inspect repository structure, build files, and task-relevant docs before editing.
+- Summarize the likely execution chain and the files that matter most to the bug.
+- Prefer targeted searches and file reads over broad scans.

package/embedded-skills/shared/repo-inspection/skill.json

@@ -0,0 +1,5 @@
+{
+  "id": "repo-inspection",
+  "level": "shared",
+  "version": "1.0.0"
+}

package/embedded-skills/task/bugfix/android-debug-protocol/SKILL.md

@@ -0,0 +1,10 @@
+# Android Debug Protocol
+
+Use this skill for Android bugfix tasks that need validation planning or debugging evidence.
+
+## Workflow
+- Prefer the strongest available validation path in the current environment.
+- Try real-device or emulator functional validation first when the environment allows it.
+- If functional validation is not feasible, fall back to local unit tests or a minimal focused test harness.
+- Use connected Android tests only when they are the strongest practical automated check.
+- If runtime validation is blocked, keep compile or code-evidence checks explicit and explain the limitation in the result.

package/embedded-skills/task/bugfix/android-debug-protocol/skill.json

@@ -0,0 +1,6 @@
+{
+  "id": "android-debug-protocol",
+  "level": "task",
+  "version": "1.0.0",
+  "taskTypes": ["bugfix"]
+}

package/harness/AGENTS.md

@@ -0,0 +1,30 @@
+# Harness Entry
+
+You are working inside the Optimus relay harness.
+
+## Read Order
+
+1. `harness/CONSTRAINTS.md`
+2. `harness/CHECKLIST.md`
+3. `doc/optimus_product_prd.md`
+4. `doc/optimus_architecture_design.md`
+5. `harness/FRAMEWORK.md`
+6. `harness/GOAL.md`
+7. `harness/TASK_PLAN.md`
+8. `harness/HANDOFF.md`
+
+## File Roles
+
+- `CONSTRAINTS.md`: project invariants
+- `CHECKLIST.md`: end-of-change self-review
+- `FRAMEWORK.md`: harness document boundaries
+- `GOAL.md`: current-stage goal and non-goals
+- `TASK_PLAN.md`: prioritized work queue
+- `HANDOFF.md`: current state, risks, next entry point
+
+## Rules
+
+- do not skip constraints or checklist
+- do not put long-term rules into `HANDOFF.md`
+- do not put stage status into `CONSTRAINTS.md`
+- when product, architecture, state, or validation conclusions change, update the matching document