@leg3ndy/otto-bridge 0.9.1 → 1.0.0

package/dist/runtime_contract.js

@@ -0,0 +1,516 @@
+function asRecord(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function asString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function normalizeStep(step) {
+    const payload = asRecord(step);
+    const stepId = asString(payload.step_id);
+    if (!stepId) {
+        return null;
+    }
+    return {
+        step_id: stepId,
+        kind: asString(payload.kind) || "tool_call",
+        status: asString(payload.status) || undefined,
+        worker_id: asString(payload.worker_id) || undefined,
+        artifact_ids: asArray(payload.artifact_ids)
+            .map((item) => asString(item))
+            .filter(Boolean),
+    };
+}
+function normalizeArtifact(artifact) {
+    const payload = asRecord(artifact);
+    const artifactId = asString(payload.artifact_id);
+    if (!artifactId) {
+        return null;
+    }
+    return {
+        artifact_id: artifactId,
+        kind: asString(payload.kind) || undefined,
+        producer_step_id: asString(payload.producer_step_id) || undefined,
+    };
+}
+function normalizeWorkspaceRoot(root) {
+    const payload = asRecord(root);
+    const rootPath = asString(payload.path);
+    if (!rootPath) {
+        return null;
+    }
+    return {
+        root_id: asString(payload.root_id) || undefined,
+        path: rootPath,
+        kind: asString(payload.kind) || undefined,
+        scope_reason: asString(payload.scope_reason) || undefined,
+        action_types: asArray(payload.action_types)
+            .map((item) => asString(item))
+            .filter(Boolean),
+        source: asString(payload.source) || undefined,
+    };
+}
+function normalizeWorkspaceTarget(target) {
+    const payload = asRecord(target);
+    const targetPath = asString(payload.path);
+    if (!targetPath) {
+        return null;
+    }
+    return {
+        target_id: asString(payload.target_id) || undefined,
+        path: targetPath,
+        kind: asString(payload.kind) || undefined,
+        access_mode: asString(payload.access_mode) || undefined,
+        action_type: asString(payload.action_type) || undefined,
+        source: asString(payload.source) || undefined,
+        step_id: asString(payload.step_id) || undefined,
+        filename: asString(payload.filename) || undefined,
+    };
+}
+function normalizeInstructionBundleDescriptor(value) {
+    const payload = asRecord(value);
+    const entrypoints = asArray(payload.entrypoints)
+        .map((item) => asString(item))
+        .filter(Boolean);
+    const precedence = asArray(payload.precedence)
+        .map((item) => asString(item))
+        .filter(Boolean);
+    const resolver = asString(payload.resolver) || undefined;
+    if (!resolver && entrypoints.length === 0 && precedence.length === 0) {
+        return undefined;
+    }
+    return {
+        resolver,
+        entrypoints,
+        precedence,
+    };
+}
+function normalizeRepoManifestDescriptor(value) {
+    const payload = asRecord(value);
+    const markerPaths = asArray(payload.marker_paths)
+        .map((item) => asString(item))
+        .filter(Boolean);
+    const manifestPaths = asArray(payload.manifest_paths)
+        .map((item) => asString(item))
+        .filter(Boolean);
+    const lockfilePaths = asArray(payload.lockfile_paths)
+        .map((item) => asString(item))
+        .filter(Boolean);
+    const includeInstructionSources = typeof payload.include_instruction_sources === "boolean"
+        ? payload.include_instruction_sources
+        : undefined;
+    const resolver = asString(payload.resolver) || undefined;
+    const vcsHint = asString(payload.vcs_hint) || undefined;
+    if (!resolver && markerPaths.length === 0 && manifestPaths.length === 0 && lockfilePaths.length === 0 && includeInstructionSources === undefined && !vcsHint) {
+        return undefined;
+    }
+    return {
+        resolver,
+        marker_paths: markerPaths,
+        manifest_paths: manifestPaths,
+        lockfile_paths: lockfilePaths,
+        include_instruction_sources: includeInstructionSources,
+        vcs_hint: vcsHint,
+    };
+}
+function normalizeWorkspaceIndexDescriptor(value) {
+    const payload = asRecord(value);
+    const ignoredDirectoryNames = asArray(payload.ignored_directory_names)
+        .map((item) => asString(item))
+        .filter(Boolean);
+    const keyFilePatterns = asArray(payload.key_file_patterns)
+        .map((item) => asString(item))
+        .filter(Boolean);
+    const resolver = asString(payload.resolver) || undefined;
+    const maxDepth = Number.isFinite(Number(payload.max_depth)) ? Number(payload.max_depth) : undefined;
+    const maxDirectories = Number.isFinite(Number(payload.max_directories)) ? Number(payload.max_directories) : undefined;
+    const maxFiles = Number.isFinite(Number(payload.max_files)) ? Number(payload.max_files) : undefined;
+    if (!resolver && ignoredDirectoryNames.length === 0 && keyFilePatterns.length === 0 && maxDepth === undefined && maxDirectories === undefined && maxFiles === undefined) {
+        return undefined;
+    }
+    return {
+        resolver,
+        max_depth: maxDepth,
+        max_directories: maxDirectories,
+        max_files: maxFiles,
+        ignored_directory_names: ignoredDirectoryNames,
+        key_file_patterns: keyFilePatterns,
+    };
+}
+function normalizeWorkspaceMemory(value) {
+    const payload = asRecord(value);
+    const memoryId = asString(payload.memory_id) || undefined;
+    const workspaceId = asString(payload.workspace_id) || undefined;
+    const source = asString(payload.source) || undefined;
+    const jobCount = Number.isFinite(Number(payload.job_count)) ? Number(payload.job_count) : undefined;
+    const recentJobIds = asArray(payload.recent_job_ids)
+        .map((item) => asString(item))
+        .filter(Boolean);
+    const recentActionTypes = asArray(payload.recent_action_types)
+        .map((item) => asString(item))
+        .filter(Boolean);
+    const recentTargetPaths = asArray(payload.recent_target_paths)
+        .map((item) => asString(item))
+        .filter(Boolean);
+    const recentArtifactKinds = asArray(payload.recent_artifact_kinds)
+        .map((item) => asString(item))
+        .filter(Boolean);
+    const latestJobId = asString(payload.latest_job_id) || undefined;
+    const latestJobStatus = asString(payload.latest_job_status) || undefined;
+    const latestJobAt = asString(payload.latest_job_at) || undefined;
+    const instructionDigest = asString(payload.instruction_digest) || undefined;
+    const repoRoot = asString(payload.repo_root) || undefined;
+    const scopedRootPath = asString(payload.scoped_root_path) || undefined;
+    const summary = asString(payload.summary) || undefined;
+    const statusCounts = Object.fromEntries(Object.entries(asRecord(payload.status_counts))
+        .map(([key, count]) => [asString(key), Number(count)])
+        .filter(([key, count]) => key && Number.isFinite(count)));
+    const retentionPayload = asRecord(payload.retention);
+    const retention = Object.keys(retentionPayload).length > 0
+        ? {
+            max_job_count: Number.isFinite(Number(retentionPayload.max_job_count)) ? Number(retentionPayload.max_job_count) : undefined,
+            max_age_days: Number.isFinite(Number(retentionPayload.max_age_days)) ? Number(retentionPayload.max_age_days) : undefined,
+            filtered_job_count: Number.isFinite(Number(retentionPayload.filtered_job_count)) ? Number(retentionPayload.filtered_job_count) : undefined,
+            window_started_at: asString(retentionPayload.window_started_at) || undefined,
+            last_cleared_at: asString(retentionPayload.last_cleared_at) || undefined,
+            last_cleared_reason: asString(retentionPayload.last_cleared_reason) || undefined,
+        }
+        : undefined;
+    const usagePolicyPayload = asRecord(payload.usage_policy);
+    const usagePolicy = Object.keys(usagePolicyPayload).length > 0
+        ? {
+            profile_id: asString(usagePolicyPayload.profile_id) || undefined,
+            summary_mode: asString(usagePolicyPayload.summary_mode) || undefined,
+            include_action_types: typeof usagePolicyPayload.include_action_types === "boolean" ? usagePolicyPayload.include_action_types : undefined,
+            include_target_paths: typeof usagePolicyPayload.include_target_paths === "boolean" ? usagePolicyPayload.include_target_paths : undefined,
+            include_artifact_kinds: typeof usagePolicyPayload.include_artifact_kinds === "boolean" ? usagePolicyPayload.include_artifact_kinds : undefined,
+            include_failed_jobs: typeof usagePolicyPayload.include_failed_jobs === "boolean" ? usagePolicyPayload.include_failed_jobs : undefined,
+            resettable: typeof usagePolicyPayload.resettable === "boolean" ? usagePolicyPayload.resettable : undefined,
+        }
+        : undefined;
+    if (!memoryId && !workspaceId && !source && jobCount === undefined && recentJobIds.length === 0 && recentActionTypes.length === 0 && recentTargetPaths.length === 0 && recentArtifactKinds.length === 0 && !latestJobId && !latestJobStatus && !latestJobAt && !instructionDigest && !repoRoot && !scopedRootPath && !summary && Object.keys(statusCounts).length === 0 && !retention && !usagePolicy) {
+        return undefined;
+    }
+    return {
+        memory_id: memoryId,
+        workspace_id: workspaceId,
+        source,
+        job_count: jobCount,
+        recent_job_ids: recentJobIds,
+        recent_action_types: recentActionTypes,
+        recent_target_paths: recentTargetPaths,
+        recent_artifact_kinds: recentArtifactKinds,
+        latest_job_id: latestJobId,
+        latest_job_status: latestJobStatus,
+        latest_job_at: latestJobAt,
+        instruction_digest: instructionDigest,
+        repo_root: repoRoot,
+        scoped_root_path: scopedRootPath,
+        summary,
+        status_counts: statusCounts,
+        retention,
+        usage_policy: usagePolicy,
+    };
+}
+function normalizeWorkspacePolicy(value) {
+    const payload = asRecord(value);
+    const profileId = asString(payload.profile_id) || undefined;
+    const title = asString(payload.title) || undefined;
+    const summary = asString(payload.summary) || undefined;
+    const rationale = asString(payload.rationale) || undefined;
+    const allowedActionTypes = asArray(payload.allowed_action_types)
+        .map((item) => asString(item).toLowerCase())
+        .filter(Boolean);
+    const blockedActionTypes = asArray(payload.blocked_action_types)
+        .map((item) => asString(item).toLowerCase())
+        .filter(Boolean);
+    const requiresConfirmationActionTypes = asArray(payload.requires_confirmation_action_types)
+        .map((item) => asString(item).toLowerCase())
+        .filter(Boolean);
+    const enforcedBy = asArray(payload.enforced_by)
+        .map((item) => asString(item))
+        .filter(Boolean);
+    const allowShell = typeof payload.allow_shell === "boolean" ? payload.allow_shell : undefined;
+    const allowCodeWrite = typeof payload.allow_code_write === "boolean" ? payload.allow_code_write : undefined;
+    const allowDestructive = typeof payload.allow_destructive === "boolean" ? payload.allow_destructive : undefined;
+    const allowRelease = typeof payload.allow_release === "boolean" ? payload.allow_release : undefined;
+    if (!profileId && !title && !summary && allowedActionTypes.length === 0 && blockedActionTypes.length === 0 && requiresConfirmationActionTypes.length === 0 && !rationale && allowShell === undefined && allowCodeWrite === undefined && allowDestructive === undefined && allowRelease === undefined && enforcedBy.length === 0) {
+        return undefined;
+    }
+    return {
+        profile_id: profileId,
+        title,
+        summary,
+        allowed_action_types: allowedActionTypes,
+        blocked_action_types: blockedActionTypes,
+        requires_confirmation_action_types: requiresConfirmationActionTypes,
+        rationale,
+        allow_shell: allowShell,
+        allow_code_write: allowCodeWrite,
+        allow_destructive: allowDestructive,
+        allow_release: allowRelease,
+        enforced_by: enforcedBy,
+    };
+}
+function normalizeWorkerProfile(value) {
+    const payload = asRecord(value);
+    const workerId = asString(payload.worker_id);
+    if (!workerId) {
+        return null;
+    }
+    return {
+        worker_id: workerId,
+        title: asString(payload.title) || undefined,
+        summary: asString(payload.summary) || undefined,
+        action_types: asArray(payload.action_types)
+            .map((item) => asString(item))
+            .filter(Boolean),
+        responsibilities: asArray(payload.responsibilities)
+            .map((item) => asString(item))
+            .filter(Boolean),
+        produces_artifact_kinds: asArray(payload.produces_artifact_kinds)
+            .map((item) => asString(item))
+            .filter(Boolean),
+        write_scope: asString(payload.write_scope) || undefined,
+        requires_confirmation: typeof payload.requires_confirmation === "boolean"
+            ? payload.requires_confirmation
+            : undefined,
+    };
+}
+function normalizeWorkerExecutionPolicy(value) {
+    const payload = asRecord(value);
+    const workerId = asString(payload.worker_id);
+    if (!workerId) {
+        return null;
+    }
+    const budgetSeconds = Number.isFinite(Number(payload.budget_seconds)) ? Number(payload.budget_seconds) : undefined;
+    const timeoutSeconds = Number.isFinite(Number(payload.timeout_seconds)) ? Number(payload.timeout_seconds) : undefined;
+    const retryLimit = Number.isFinite(Number(payload.retry_limit)) ? Number(payload.retry_limit) : undefined;
+    const maxParallelTasks = Number.isFinite(Number(payload.max_parallel_tasks)) ? Number(payload.max_parallel_tasks) : undefined;
+    return {
+        worker_id: workerId,
+        budget_seconds: budgetSeconds,
+        timeout_seconds: timeoutSeconds,
+        retry_limit: retryLimit,
+        max_parallel_tasks: maxParallelTasks,
+    };
+}
+function normalizeCommandPack(value) {
+    const payload = asRecord(value);
+    const packId = asString(payload.pack_id);
+    if (!packId) {
+        return null;
+    }
+    return {
+        pack_id: packId,
+        title: asString(payload.title) || undefined,
+        summary: asString(payload.summary) || undefined,
+        selected: typeof payload.selected === "boolean" ? payload.selected : undefined,
+        intensity: asString(payload.intensity) || undefined,
+        reason: asString(payload.reason) || undefined,
+        worker_ids: asArray(payload.worker_ids)
+            .map((item) => asString(item))
+            .filter(Boolean),
+        prompt_hints: asArray(payload.prompt_hints)
+            .map((item) => asString(item))
+            .filter(Boolean),
+    };
+}
+function normalizeInstructionUpdate(value) {
+    const payload = asRecord(value);
+    const updaterId = asString(payload.updater_id);
+    if (!updaterId) {
+        return undefined;
+    }
+    return {
+        updater_id: updaterId,
+        resolver: asString(payload.resolver) || undefined,
+        selected: typeof payload.selected === "boolean" ? payload.selected : undefined,
+        reason: asString(payload.reason) || undefined,
+        source_entrypoints: asArray(payload.source_entrypoints)
+            .map((item) => asString(item))
+            .filter(Boolean),
+        target_paths: asArray(payload.target_paths)
+            .map((item) => asString(item))
+            .filter(Boolean),
+        recommended_validation_stage_ids: asArray(payload.recommended_validation_stage_ids)
+            .map((item) => asString(item))
+            .filter(Boolean),
+    };
+}
+function normalizeValidationLadderStage(value) {
+    const payload = asRecord(value);
+    const stageId = asString(payload.stage_id);
+    if (!stageId) {
+        return null;
+    }
+    const order = Number.isFinite(Number(payload.order)) ? Number(payload.order) : undefined;
+    return {
+        stage_id: stageId,
+        title: asString(payload.title) || undefined,
+        order,
+        required: typeof payload.required === "boolean" ? payload.required : undefined,
+        profile: asString(payload.profile) || undefined,
+        command_hint: asString(payload.command_hint) || undefined,
+        stack_tags: asArray(payload.stack_tags)
+            .map((item) => asString(item).toLowerCase())
+            .filter(Boolean),
+    };
+}
+function normalizeValidationLadder(value) {
+    const payload = asRecord(value);
+    const ladderId = asString(payload.ladder_id);
+    if (!ladderId) {
+        return undefined;
+    }
+    return {
+        ladder_id: ladderId,
+        resolver: asString(payload.resolver) || undefined,
+        title: asString(payload.title) || undefined,
+        summary: asString(payload.summary) || undefined,
+        stop_on_failure: typeof payload.stop_on_failure === "boolean" ? payload.stop_on_failure : undefined,
+        selected_command_pack_id: asString(payload.selected_command_pack_id) || undefined,
+        stages: asArray(payload.stages)
+            .map((item) => normalizeValidationLadderStage(item))
+            .filter((item) => Boolean(item)),
+    };
+}
+function normalizeHookBus(value) {
+    const payload = asRecord(value);
+    const busId = asString(payload.bus_id) || undefined;
+    const resolver = asString(payload.resolver) || undefined;
+    const summary = asString(payload.summary) || undefined;
+    const events = asArray(payload.events)
+        .map((item) => asString(item))
+        .filter(Boolean);
+    const sinks = asArray(payload.sinks)
+        .map((item) => asString(item))
+        .filter(Boolean);
+    if (!busId && !resolver && !summary && events.length === 0 && sinks.length === 0) {
+        return undefined;
+    }
+    return {
+        bus_id: busId,
+        resolver,
+        summary,
+        events,
+        sinks,
+        replay_enabled: typeof payload.replay_enabled === "boolean" ? payload.replay_enabled : undefined,
+        metrics_enabled: typeof payload.metrics_enabled === "boolean" ? payload.metrics_enabled : undefined,
+        enforcement_enabled: typeof payload.enforcement_enabled === "boolean" ? payload.enforcement_enabled : undefined,
+    };
+}
+function normalizeWorkspaceContext(value) {
+    const payload = asRecord(value);
+    const roots = asArray(payload.roots)
+        .map((item) => normalizeWorkspaceRoot(item))
+        .filter((item) => Boolean(item));
+    const targets = asArray(payload.targets)
+        .map((item) => normalizeWorkspaceTarget(item))
+        .filter((item) => Boolean(item));
+    const instructionBundle = normalizeInstructionBundleDescriptor(payload.instruction_bundle);
+    const repoManifest = normalizeRepoManifestDescriptor(payload.repo_manifest);
+    const workspaceIndex = normalizeWorkspaceIndexDescriptor(payload.workspace_index);
+    const workspaceMemory = normalizeWorkspaceMemory(payload.workspace_memory);
+    const workspacePolicy = normalizeWorkspacePolicy(payload.workspace_policy);
+    const workspaceId = asString(payload.workspace_id) || undefined;
+    if (!workspaceId && roots.length === 0 && targets.length === 0 && !instructionBundle && !repoManifest && !workspaceIndex && !workspaceMemory && !workspacePolicy) {
+        return undefined;
+    }
+    return {
+        workspace_id: workspaceId,
+        roots,
+        targets,
+        instruction_bundle: instructionBundle,
+        repo_manifest: repoManifest,
+        workspace_index: workspaceIndex,
+        workspace_memory: workspaceMemory,
+        workspace_policy: workspacePolicy,
+    };
+}
+export function parseJobRuntimeManifest(job) {
+    const payload = asRecord(job.payload);
+    const runtimeState = asRecord(payload.runtime_state);
+    const runtimeContract = asRecord(payload.runtime_contract);
+    const executionGraph = asRecord(runtimeContract.execution_graph);
+    const steps = asArray(executionGraph.steps)
+        .map((item) => normalizeStep(item))
+        .filter((item) => Boolean(item));
+    const expectedArtifacts = asArray(runtimeContract.expected_artifacts)
+        .map((item) => normalizeArtifact(item))
+        .filter((item) => Boolean(item));
+    const workerProfiles = asArray(runtimeContract.worker_profiles)
+        .map((item) => normalizeWorkerProfile(item))
+        .filter((item) => Boolean(item));
+    const workerExecution = asArray(runtimeContract.worker_execution)
+        .map((item) => normalizeWorkerExecutionPolicy(item))
+        .filter((item) => Boolean(item));
+    const commandPacks = asArray(runtimeContract.command_packs)
+        .map((item) => normalizeCommandPack(item))
+        .filter((item) => Boolean(item));
+    const approvalStepId = steps.find((step) => step.kind === "approval_gate")?.step_id;
+    const toolSteps = steps.filter((step) => step.kind === "tool_call");
+    const executionStepId = toolSteps[0]?.step_id;
+    const finalizeStepId = steps.find((step) => step.kind === "finalize")?.step_id;
+    return {
+        graphId: asString(runtimeState.graph_id) || asString(executionGraph.graph_id) || undefined,
+        currentStepId: asString(runtimeState.current_step_id) || undefined,
+        requiresConfirmation: payload.requires_confirmation === true,
+        steps,
+        toolSteps,
+        expectedArtifacts,
+        workerProfiles,
+        workerExecution,
+        commandPacks,
+        instructionUpdate: normalizeInstructionUpdate(runtimeContract.instruction_update),
+        validationLadder: normalizeValidationLadder(runtimeContract.validation_ladder),
+        hookBus: normalizeHookBus(runtimeContract.hook_bus),
+        approvalStepId,
+        executionStepId,
+        finalizeStepId,
+        workspaceContext: normalizeWorkspaceContext(runtimeContract.workspace_context),
+    };
+}
+export function runtimeStepIdForActionIndex(manifest, actionIndex) {
+    if (actionIndex < 0) {
+        return undefined;
+    }
+    return manifest.toolSteps[actionIndex]?.step_id;
+}
+export function runtimeStepIdForEvent(manifest, eventType) {
+    if (eventType === "confirm_required") {
+        return manifest.approvalStepId || manifest.currentStepId || manifest.executionStepId;
+    }
+    if (eventType === "accepted") {
+        if (manifest.requiresConfirmation && manifest.approvalStepId) {
+            return manifest.approvalStepId;
+        }
+        return manifest.executionStepId || manifest.currentStepId || manifest.finalizeStepId;
+    }
+    if (eventType === "progress") {
+        return manifest.executionStepId || manifest.currentStepId || manifest.finalizeStepId;
+    }
+    if (eventType === "completed") {
+        return manifest.finalizeStepId || manifest.currentStepId || manifest.executionStepId;
+    }
+    return manifest.currentStepId || manifest.executionStepId || manifest.finalizeStepId || manifest.approvalStepId;
+}
+export function runtimeExpectedArtifactIdForActionIndex(manifest, actionIndex, expectedKind) {
+    const stepId = runtimeStepIdForActionIndex(manifest, actionIndex);
+    if (!stepId) {
+        return undefined;
+    }
+    const normalizedExpectedKind = asString(expectedKind).toLowerCase();
+    const exact = manifest.expectedArtifacts.find((artifact) => {
+        if (asString(artifact.producer_step_id) !== stepId) {
+            return false;
+        }
+        if (!normalizedExpectedKind) {
+            return true;
+        }
+        return asString(artifact.kind).toLowerCase() === normalizedExpectedKind;
+    });
+    return exact?.artifact_id;
+}

package/dist/tool_catalog.js

@@ -65,6 +65,170 @@ const NATIVE_MACOS_BASE_TOOLS = [
         mode: "observe",
         action_types: ["read_file"],
     },
+    {
+        id: "filesystem.write_text",
+        title: "Escrita de arquivo de texto",
+        description: "Cria ou atualiza arquivos .txt em caminhos locais, incluindo Desktop e outras pastas do usuario.",
+        category: "filesystem",
+        mode: "write",
+        action_types: ["write_text_file"],
+    },
+    {
+        id: "filesystem.write_json",
+        title: "Escrita de arquivo JSON",
+        description: "Grava arquivos JSON estruturados em caminhos locais do workspace.",
+        category: "filesystem",
+        mode: "write",
+        action_types: ["write_json_file"],
+    },
+    {
+        id: "workspace.patch",
+        title: "Aplicar patch no workspace",
+        description: "Aplica um patch estruturado em arquivos do workspace ativo e devolve um patch_set auditavel.",
+        category: "filesystem",
+        mode: "write",
+        action_types: ["apply_patch"],
+    },
+    {
+        id: "filesystem.mkdir",
+        title: "Criar pasta local",
+        description: "Cria pastas locais dentro do workspace ativo.",
+        category: "filesystem",
+        mode: "write",
+        action_types: ["mkdir"],
+    },
+    {
+        id: "filesystem.move",
+        title: "Mover item local",
+        description: "Move ou renomeia arquivos e pastas locais dentro do workspace ativo.",
+        category: "filesystem",
+        mode: "write",
+        action_types: ["move_file"],
+        requires_confirmation: true,
+    },
+    {
+        id: "filesystem.trash",
+        title: "Mover item para a Lixeira",
+        description: "Move arquivos e pastas locais para a Lixeira do macOS com confirmação.",
+        category: "filesystem",
+        mode: "write",
+        action_types: ["trash_path"],
+        requires_confirmation: true,
+    },
+    {
+        id: "filesystem.delete",
+        title: "Apagar arquivo local",
+        description: "Apaga permanentemente um arquivo local dentro do workspace ativo com confirmação.",
+        category: "filesystem",
+        mode: "write",
+        action_types: ["delete_file"],
+        requires_confirmation: true,
+    },
+    {
+        id: "git.status",
+        title: "Estado do Git",
+        description: "Lê branch, staged, unstaged e arquivos modificados do repositório local ativo.",
+        category: "git",
+        mode: "observe",
+        action_types: ["git_status"],
+    },
+    {
+        id: "git.diff",
+        title: "Diff do Git",
+        description: "Lê o diff atual ou staged do repositório local ativo.",
+        category: "git",
+        mode: "observe",
+        action_types: ["git_diff"],
+    },
+    {
+        id: "git.stage",
+        title: "Stage do Git",
+        description: "Prepara arquivos ou todas as mudanças pendentes no stage do repositório local ativo.",
+        category: "git",
+        mode: "write",
+        action_types: ["git_add"],
+        requires_confirmation: true,
+    },
+    {
+        id: "git.commit",
+        title: "Commit do Git",
+        description: "Cria um commit local no repositório ativo com mensagem explícita.",
+        category: "git",
+        mode: "write",
+        action_types: ["git_commit"],
+        requires_confirmation: true,
+    },
+    {
+        id: "git.push",
+        title: "Push do Git",
+        description: "Envia a branch local do repositório ativo para o remote configurado.",
+        category: "git",
+        mode: "write",
+        action_types: ["git_push"],
+        requires_confirmation: true,
+    },
+    {
+        id: "git.clone",
+        title: "Clone do Git",
+        description: "Clona um repositório Git em um destino local declarado dentro do workspace ativo.",
+        category: "git",
+        mode: "write",
+        action_types: ["git_clone"],
+        requires_confirmation: true,
+    },
+    {
+        id: "git.fetch",
+        title: "Fetch do Git",
+        description: "Atualiza refs e branches remotas do repositório local ativo.",
+        category: "git",
+        mode: "write",
+        action_types: ["git_fetch"],
+        requires_confirmation: true,
+    },
+    {
+        id: "git.checkout",
+        title: "Checkout do Git",
+        description: "Troca branch, cria branch local ou entra em detached HEAD no repositório ativo.",
+        category: "git",
+        mode: "write",
+        action_types: ["git_checkout"],
+        requires_confirmation: true,
+    },
+    {
+        id: "git.rebase",
+        title: "Rebase do Git",
+        description: "Rebaseia a branch atual sobre uma branch ou ref alvo do repositório ativo.",
+        category: "git",
+        mode: "write",
+        action_types: ["git_rebase"],
+        requires_confirmation: true,
+    },
+    {
+        id: "git.merge",
+        title: "Merge do Git",
+        description: "Mescla uma branch ou ref alvo na branch atual do repositório ativo.",
+        category: "git",
+        mode: "write",
+        action_types: ["git_merge"],
+        requires_confirmation: true,
+    },
+    {
+        id: "git.tag",
+        title: "Tag do Git",
+        description: "Cria uma tag local no repositório ativo com nome e anotação auditáveis.",
+        category: "git",
+        mode: "write",
+        action_types: ["git_tag"],
+        requires_confirmation: true,
+    },
+    {
+        id: "workspace.tests",
+        title: "Executar testes",
+        description: "Roda testes automatizados ou perfis de validacao do projeto dentro do workspace ativo e devolve relatório estruturado.",
+        category: "validation",
+        mode: "control",
+        action_types: ["run_tests"],
+    },
     {
         id: "system.health",
         title: "Status do Mac",