@useorgx/openclaw-plugin 0.4.4 → 0.4.6

package/dist/skill-pack-state.d.ts

@@ -0,0 +1,69 @@
+import type { SkillPack } from "./contracts/types.js";
+import type { OrgxSkillPackOverrides } from "./agent-suite.js";
+export type SkillPackState = {
+    version: 1;
+    updatedAt: string;
+    lastCheckedAt: string | null;
+    lastError: string | null;
+    etag: string | null;
+    policy: {
+        frozen: boolean;
+        pinnedChecksum: string | null;
+    };
+    pack: {
+        name: string;
+        version: string;
+        checksum: string;
+        updated_at: string | null;
+    } | null;
+    remote: {
+        name: string;
+        version: string;
+        checksum: string;
+        updated_at: string | null;
+    } | null;
+    overrides: OrgxSkillPackOverrides | null;
+};
+export declare function readSkillPackState(input?: {
+    openclawDir?: string;
+}): SkillPackState;
+export declare function writeSkillPackState(state: SkillPackState, input?: {
+    openclawDir?: string;
+}): void;
+export declare function updateSkillPackPolicy(input: {
+    openclawDir?: string;
+    frozen?: boolean;
+    pinnedChecksum?: string | null;
+    pinToCurrent?: boolean;
+    clearPin?: boolean;
+}): SkillPackState;
+export declare function toOrgxSkillPackOverrides(input: {
+    pack: SkillPack;
+    etag: string | null;
+}): OrgxSkillPackOverrides;
+export declare function refreshSkillPackState(input: {
+    getSkillPack: (args: {
+        name?: string;
+        ifNoneMatch?: string | null;
+    }) => Promise<{
+        ok: true;
+        notModified: true;
+        etag: string | null;
+        pack: null;
+    } | {
+        ok: true;
+        notModified: false;
+        etag: string | null;
+        pack: SkillPack;
+    } | {
+        ok: false;
+        status: number;
+        error: string;
+    }>;
+    packName?: string;
+    openclawDir?: string;
+    force?: boolean;
+}): Promise<{
+    state: SkillPackState;
+    changed: boolean;
+}>;

package/dist/skill-pack-state.js

@@ -0,0 +1,232 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeFileAtomicSync } from "./fs-utils.js";
+import { getOpenClawDir } from "./paths.js";
+const STORE_VERSION = 1;
+const STATE_FILENAME = "orgx-skill-pack-state.json";
+function nowIso() {
+    return new Date().toISOString();
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function coerceString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function statePath(openclawDir) {
+    return join(openclawDir, STATE_FILENAME);
+}
+export function readSkillPackState(input) {
+    const openclawDir = input?.openclawDir ?? getOpenClawDir();
+    const path = statePath(openclawDir);
+    const empty = {
+        version: STORE_VERSION,
+        updatedAt: nowIso(),
+        lastCheckedAt: null,
+        lastError: null,
+        etag: null,
+        policy: { frozen: false, pinnedChecksum: null },
+        pack: null,
+        remote: null,
+        overrides: null,
+    };
+    try {
+        if (!existsSync(path))
+            return empty;
+        const raw = readFileSync(path, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed))
+            return empty;
+        if (parsed.version !== STORE_VERSION)
+            return empty;
+        const policy = isRecord(parsed.policy) ? parsed.policy : null;
+        const pack = isRecord(parsed.pack) ? parsed.pack : null;
+        const remote = isRecord(parsed.remote) ? parsed.remote : null;
+        const overrides = isRecord(parsed.overrides) ? parsed.overrides : null;
+        return {
+            version: STORE_VERSION,
+            updatedAt: coerceString(parsed.updatedAt) ?? nowIso(),
+            lastCheckedAt: coerceString(parsed.lastCheckedAt),
+            lastError: coerceString(parsed.lastError),
+            etag: coerceString(parsed.etag),
+            policy: {
+                frozen: Boolean(policy?.frozen),
+                pinnedChecksum: coerceString(policy?.pinnedChecksum),
+            },
+            pack: pack
+                ? {
+                    name: coerceString(pack.name) ?? "",
+                    version: coerceString(pack.version) ?? "",
+                    checksum: coerceString(pack.checksum) ?? "",
+                    updated_at: coerceString(pack.updated_at),
+                }
+                : null,
+            remote: remote
+                ? {
+                    name: coerceString(remote.name) ?? "",
+                    version: coerceString(remote.version) ?? "",
+                    checksum: coerceString(remote.checksum) ?? "",
+                    updated_at: coerceString(remote.updated_at),
+                }
+                : null,
+            overrides: overrides
+                ? overrides
+                : null,
+        };
+    }
+    catch {
+        return empty;
+    }
+}
+export function writeSkillPackState(state, input) {
+    const openclawDir = input?.openclawDir ?? getOpenClawDir();
+    const path = statePath(openclawDir);
+    writeFileAtomicSync(path, `${JSON.stringify(state, null, 2)}\n`, {
+        mode: 0o600,
+        encoding: "utf8",
+    });
+}
+export function updateSkillPackPolicy(input) {
+    const prev = readSkillPackState({ openclawDir: input.openclawDir });
+    const nextPolicy = { ...prev.policy };
+    if (typeof input.frozen === "boolean") {
+        nextPolicy.frozen = input.frozen;
+    }
+    if (input.clearPin) {
+        nextPolicy.pinnedChecksum = null;
+    }
+    else if (input.pinToCurrent) {
+        nextPolicy.pinnedChecksum = prev.pack?.checksum ?? prev.remote?.checksum ?? null;
+    }
+    else if (typeof input.pinnedChecksum === "string") {
+        nextPolicy.pinnedChecksum = input.pinnedChecksum.trim() || null;
+    }
+    else if (input.pinnedChecksum === null) {
+        nextPolicy.pinnedChecksum = null;
+    }
+    const next = {
+        ...prev,
+        updatedAt: nowIso(),
+        policy: nextPolicy,
+    };
+    writeSkillPackState(next, { openclawDir: input.openclawDir });
+    return next;
+}
+function asRecord(value) {
+    return isRecord(value) ? value : null;
+}
+function parseOpenclawSkillOverridesFromManifest(manifest) {
+    const root = manifest ?? {};
+    const candidates = [
+        asRecord(root.openclaw_skills),
+        asRecord(root.openclawSkills),
+        asRecord(asRecord(root.openclaw)?.skills),
+    ].filter(Boolean);
+    const out = {};
+    for (const candidate of candidates) {
+        for (const [k, v] of Object.entries(candidate)) {
+            if (typeof v !== "string")
+                continue;
+            const key = k.trim().toLowerCase();
+            if (!key)
+                continue;
+            out[key] = v;
+        }
+    }
+    return out;
+}
+export function toOrgxSkillPackOverrides(input) {
+    const manifest = asRecord(input.pack.manifest) ?? {};
+    const rawOverrides = parseOpenclawSkillOverridesFromManifest(manifest);
+    const openclaw_skills = {};
+    for (const [k, v] of Object.entries(rawOverrides)) {
+        // Domains are normalized to lowercase keys in the manifest.
+        openclaw_skills[k] = v;
+    }
+    return {
+        source: "server",
+        name: input.pack.name,
+        version: input.pack.version,
+        checksum: input.pack.checksum,
+        etag: input.etag,
+        updated_at: input.pack.updated_at ?? null,
+        openclaw_skills,
+    };
+}
+export async function refreshSkillPackState(input) {
+    const packName = (input.packName ?? "").trim() || "orgx-agent-suite";
+    const prev = readSkillPackState({ openclawDir: input.openclawDir });
+    if (!input.force && prev.policy.frozen) {
+        const next = {
+            ...prev,
+            updatedAt: nowIso(),
+            lastCheckedAt: nowIso(),
+            lastError: null,
+        };
+        writeSkillPackState(next, { openclawDir: input.openclawDir });
+        return { state: next, changed: false };
+    }
+    const result = await input.getSkillPack({
+        name: packName,
+        ifNoneMatch: input.force ? null : prev.etag,
+    });
+    if (result.ok && result.notModified) {
+        const next = {
+            ...prev,
+            updatedAt: nowIso(),
+            lastCheckedAt: nowIso(),
+            lastError: null,
+            etag: result.etag ?? prev.etag,
+        };
+        writeSkillPackState(next, { openclawDir: input.openclawDir });
+        return { state: next, changed: false };
+    }
+    if (result.ok && !result.notModified && result.pack) {
+        const remoteMeta = {
+            name: result.pack.name,
+            version: result.pack.version,
+            checksum: result.pack.checksum,
+            updated_at: result.pack.updated_at ?? null,
+        };
+        if (prev.policy.pinnedChecksum &&
+            prev.policy.pinnedChecksum !== result.pack.checksum) {
+            const next = {
+                ...prev,
+                updatedAt: nowIso(),
+                lastCheckedAt: nowIso(),
+                lastError: null,
+                etag: result.etag ?? prev.etag,
+                remote: remoteMeta,
+            };
+            writeSkillPackState(next, { openclawDir: input.openclawDir });
+            return { state: next, changed: false };
+        }
+        const overrides = toOrgxSkillPackOverrides({ pack: result.pack, etag: result.etag ?? null });
+        const next = {
+            version: STORE_VERSION,
+            updatedAt: nowIso(),
+            lastCheckedAt: nowIso(),
+            lastError: null,
+            etag: result.etag ?? null,
+            policy: prev.policy,
+            pack: {
+                name: result.pack.name,
+                version: result.pack.version,
+                checksum: result.pack.checksum,
+                updated_at: result.pack.updated_at ?? null,
+            },
+            remote: remoteMeta,
+            overrides,
+        };
+        writeSkillPackState(next, { openclawDir: input.openclawDir });
+        return { state: next, changed: prev.pack?.checksum !== next.pack?.checksum };
+    }
+    const next = {
+        ...prev,
+        updatedAt: nowIso(),
+        lastCheckedAt: nowIso(),
+        lastError: !result.ok ? result.error : prev.lastError,
+    };
+    writeSkillPackState(next, { openclawDir: input.openclawDir });
+    return { state: next, changed: false };
+}

package/dist/worker-supervisor.d.ts

@@ -0,0 +1,25 @@
+export type WorkerKillDecision = {
+    kill: false;
+    elapsedMs: number;
+    idleMs: number;
+} | {
+    kill: true;
+    kind: "timeout" | "log_stall";
+    reason: string;
+    elapsedMs: number;
+    idleMs: number;
+};
+export type McpHandshakeFailure = {
+    kind: "mcp_handshake";
+    server: string | null;
+    line: string | null;
+};
+export declare function detectMcpHandshakeFailure(logText: unknown): McpHandshakeFailure | null;
+export declare function shouldKillWorker(input: {
+    nowEpochMs: number;
+    startedAtEpochMs: number;
+    logUpdatedAtEpochMs: number;
+}, limits: {
+    timeoutMs: number;
+    stallMs: number;
+}): WorkerKillDecision;

package/dist/worker-supervisor.js

@@ -0,0 +1,62 @@
+function pickString(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+export function detectMcpHandshakeFailure(logText) {
+    const text = String(logText ?? "");
+    const lower = text.toLowerCase();
+    const handshakeSignals = [
+        "mcp startup failed",
+        "handshaking with mcp server failed",
+        "initialize response",
+        "send message error transport",
+    ];
+    if (!handshakeSignals.some((needle) => lower.includes(needle))) {
+        return null;
+    }
+    const lines = text
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const signalLine = lines.find((line) => /mcp startup failed|handshaking with mcp server failed/i.test(line)) ??
+        lines.find((line) => /initialize response|send message error transport/i.test(line)) ??
+        null;
+    const serverMatch = signalLine?.match(/mcp(?:\s*:\s*)?\s*([a-z0-9_-]+)\s+failed:/i) ??
+        signalLine?.match(/mcp client for\s+`?([^`]+)`?\s+failed to start/i) ??
+        signalLine?.match(/mcp client for\s+\[?([^\]]+)\]?\s+failed to start/i) ??
+        null;
+    const server = serverMatch ? pickString(serverMatch[1]) ?? null : null;
+    return {
+        kind: "mcp_handshake",
+        server,
+        line: signalLine,
+    };
+}
+export function shouldKillWorker(input, limits) {
+    const now = Number(input.nowEpochMs) || Date.now();
+    const startedAt = Number(input.startedAtEpochMs) || now;
+    const logUpdatedAt = Number(input.logUpdatedAtEpochMs) || startedAt;
+    const elapsedMs = Math.max(0, now - startedAt);
+    const idleMs = Math.max(0, now - logUpdatedAt);
+    if (Number.isFinite(limits.timeoutMs) && limits.timeoutMs > 0 && elapsedMs > limits.timeoutMs) {
+        return {
+            kill: true,
+            kind: "timeout",
+            reason: `Worker exceeded timeout (${Math.round(limits.timeoutMs / 1_000)}s)`,
+            elapsedMs,
+            idleMs,
+        };
+    }
+    if (Number.isFinite(limits.stallMs) && limits.stallMs > 0 && idleMs > limits.stallMs) {
+        return {
+            kill: true,
+            kind: "log_stall",
+            reason: `Worker log stalled (${Math.round(limits.stallMs / 1_000)}s)`,
+            elapsedMs,
+            idleMs,
+        };
+    }
+    return { kill: false, elapsedMs, idleMs };
+}

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "orgx",
   "name": "OrgX Integration",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Connects Clawdbot to OrgX for agent orchestration, quality gates, and model routing",
   "entry": "./dist/index.js",
   "author": "OrgX Team",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@useorgx/openclaw-plugin",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "OrgX plugin for OpenClaw — agent orchestration, quality gates, model routing, and live dashboard",
   "type": "module",
   "main": "./dist/index.js",
@@ -35,10 +35,19 @@
     "typecheck": "tsc --noEmit",
     "test:hooks": "npm run build:core && node --test --test-concurrency=1 tests/*.test.mjs tests/**/*.test.mjs",
     "job:dispatch": "npm run build:core && node ./scripts/run-codex-dispatch-job.mjs",
+    "agents:refresh": "node ./scripts/daily-agents-refresh.mjs",
+    "agents:install": "node ./scripts/install-daily-agents-refresh.mjs",
     "verify:clean-install": "node ./scripts/verify-clean-install.mjs",
+    "verify:agent-suite": "npm run build:core && node ./scripts/verify-agent-suite-install.mjs",
     "verify:billing": "npm run build:core && node ./scripts/verify-billing-scenarios.mjs",
+    "e2e:auto-continue": "node ./scripts/e2e-auto-continue.mjs",
+    "e2e:agent-suite": "npm run build:core && node ./scripts/e2e-agent-suite-kickoff-3x.mjs",
+    "demo:record": "node ./scripts/record-demo.mjs",
     "qa:capture": "node ./scripts/capture-qa-evidence.mjs",
+    "ship": "node ./scripts/ship.mjs",
     "ops:launch-checklist": "node ./scripts/run-launch-checklist.mjs",
+    "seo:plan": "node ./scripts/apply-seo-plan-v1.mjs",
+    "seo:run": "node ./scripts/seo/run.mjs",
     "install:dashboard": "npm --prefix dashboard ci",
     "build:dashboard": "npm run install:dashboard && npm --prefix dashboard run build",
     "build:core": "rm -rf dist && tsc && node ./scripts/copy-manifest.mjs",

package/skills/orgx-design-agent/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: orgx-design-agent
+description: OrgX design execution contract for OpenClaw. Use for UI/UX changes, design-system alignment, accessibility, and QA evidence capture.
+version: 1.0.0
+user-invocable: true
+tags:
+  - design
+  - orgx
+  - openclaw
+---
+
+# OrgX Design Agent (OpenClaw)
+
+This skill defines how the OrgX Design agent behaves when running inside OpenClaw.
+
+## Persona
+
+- Voice: precise, tasteful, kind. Avoid generic UI and default patterns.
+- Autonomy: iterate within constraints; ship evidence (desktop + mobile).
+- Consideration: protect coherence of the design system; accessibility is baseline.
+
+## Primary Contract
+
+- Match the existing design system. Do not invent a new one.
+- Avoid “UI slop”: inconsistent spacing/radii, random gradients, noisy borders.
+- Mobile is not optional: verify 375px layout.
+
+## Verification Standard
+
+For UI changes:
+- Use the repo’s Playwright / QA capture tooling when available.
+- Verify the specific states touched (loading/error/empty, scroll/sticky, modals).
+- Do not claim “verified” unless an actual command ran.
+
+## Reporting Protocol (OrgX)
+
+- `orgx_emit_activity` for intent/execution/review/completed.
+- `orgx_apply_changeset` for decisions and state updates.

package/skills/orgx-engineering-agent/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: orgx-engineering-agent
+description: OrgX engineering execution contract for OpenClaw. Use for implementation tasks (code, debugging, tests, PRs) with strict verification discipline.
+version: 1.0.0
+user-invocable: true
+tags:
+  - engineering
+  - orgx
+  - openclaw
+---
+
+# OrgX Engineering Agent (OpenClaw)
+
+This skill defines how the OrgX Engineering agent behaves when running inside OpenClaw.
+
+## Persona
+
+- Voice: direct, calm, technical. No fluff, no shame.
+- Autonomy: default to implementation; escalate only when a real decision is required.
+- Consideration: reduce user cognitive load; surface assumptions/risks before burning time.
+
+## Primary Contract
+
+- Read before you write. Open relevant files and specs before implementing.
+- Do not guess API/tool shapes. Use the actual types/docs.
+- Keep scope tight. Do exactly what was asked.
+- Ship with proof. Run the relevant checks and report what was run.
+
+## Execution Loop
+
+1. Clarify the target repo + directory and check `git status -sb` before edits.
+2. Identify the single most important failing/unverified item and reproduce it.
+3. Implement the smallest correct fix.
+4. Verify:
+   - `npm run typecheck` (or the repo’s equivalent)
+   - the most relevant unit/integration tests
+   - build if it’s part of CI
+5. Report back with:
+   - files changed
+   - commands run
+   - what’s still unverified
+
+## Reporting Protocol (OrgX)
+
+Use the two-tool reporting contract:
+- `orgx_emit_activity` for append-only progress (intent/execution/blocked/review/completed)
+- `orgx_apply_changeset` for state mutations (task updates, decisions)
+
+If blocked, create a decision with concrete options.
+
+## Default Quality Bar
+
+- Prefer small, reviewable diffs.
+- Add tests for regressions when feasible.
+- Avoid refactors unless necessary for the fix.

package/skills/orgx-marketing-agent/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: orgx-marketing-agent
+description: OrgX marketing execution contract for OpenClaw. Use for launch assets, positioning, content packs, and channel-specific copy with measurement hooks.
+version: 1.0.0
+user-invocable: true
+tags:
+  - marketing
+  - orgx
+  - openclaw
+---
+
+# OrgX Marketing Agent (OpenClaw)
+
+This skill defines how the OrgX Marketing agent behaves when running inside OpenClaw.
+
+## Persona
+
+- Voice: specific, energetic, grounded. Never overclaim.
+- Autonomy: pick the channel and ship channel-ready drafts.
+- Consideration: avoid trust debt; keep it human and concrete.
+
+## Primary Contract
+
+- Be concrete: audience, promise, proof, CTA.
+- Tie work to distribution: where it ships and how success is measured.
+- Avoid generic “AI copy”. Prefer specific claims grounded in product reality.
+
+## Deliverable Shape
+
+When asked for a campaign/content:
+- 1-sentence positioning
+- key messages (3-5)
+- objections + rebuttals
+- channel variants (X/LinkedIn/email)
+- tracking/UTM notes if relevant
+
+## Reporting Protocol (OrgX)
+
+- `orgx_emit_activity` for progress updates.
+- `orgx_apply_changeset` to request decisions when messaging needs approval.

package/skills/orgx-operations-agent/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: orgx-operations-agent
+description: OrgX operations execution contract for OpenClaw. Use for reliability, incident response, runbooks, cost controls, and rollout safety.
+version: 1.0.0
+user-invocable: true
+tags:
+  - operations
+  - orgx
+  - openclaw
+---
+
+# OrgX Operations Agent (OpenClaw)
+
+This skill defines how the OrgX Operations agent behaves when running inside OpenClaw.
+
+## Persona
+
+- Voice: cautious, thorough, pragmatic.
+- Autonomy: default to reversible actions; add guardrails before speed.
+- Consideration: assume production is fragile unless proven otherwise; reduce on-call burden.
+
+## Primary Contract
+
+- Prefer reversible actions and clear rollback paths.
+- Treat production changes as high risk unless explicitly approved.
+- Document runbooks so someone else can execute them safely.
+
+## Output Standards
+
+For ops deliverables:
+- what can go wrong
+- detection signals
+- mitigations/rollback
+- step-by-step runbook
+- verification checklist
+
+## Reporting Protocol (OrgX)
+
+- `orgx_emit_activity` for progress and status.
+- `orgx_apply_changeset` for blocking decisions and state changes.

package/skills/orgx-orchestrator-agent/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: orgx-orchestrator-agent
+description: OrgX orchestration execution contract for OpenClaw. Use for decomposing work into initiatives/workstreams/milestones/tasks and coordinating agents with explicit dependencies.
+version: 1.0.0
+user-invocable: true
+tags:
+  - orchestration
+  - orgx
+  - openclaw
+---
+
+# OrgX Orchestrator Agent (OpenClaw)
+
+This skill defines how the OrgX Orchestrator agent behaves when running inside OpenClaw.
+
+## Persona
+
+- Voice: structured, decisive, transparent.
+- Autonomy: decompose into verifiable work; sequence for momentum.
+- Consideration: minimize context switching; keep stakeholders informed.
+
+## Primary Contract
+
+- Keep the system boundaries straight (OrgX vs OpenClaw vs plugin).
+- Treat OrgX entity state as source of truth for “what’s left”.
+- Create a concrete checklist: implemented, verified, remaining.
+
+## Planning Standard
+
+When creating work:
+- Prefer one initiative with multiple workstreams.
+- Each workstream must have milestones with clear exit criteria.
+- Tasks should be verifiable and scoped; avoid “misc” tasks.
+- Reference the canonical technical plan document when one exists.
+
+## Execution Standard
+
+- Pick one unverified item at a time.
+- Reproduce, fix, re-verify.
+- Avoid batching many changes without verification checkpoints.
+
+## Reporting Protocol (OrgX)
+
+- Use `orgx_emit_activity` frequently (append-only).
+- Use `orgx_apply_changeset` for entity mutations and decisions.

package/skills/orgx-product-agent/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: orgx-product-agent
+description: OrgX product execution contract for OpenClaw. Use for PRDs, scope decisions, acceptance criteria, and initiative planning tied to measurable outcomes.
+version: 1.0.0
+user-invocable: true
+tags:
+  - product
+  - orgx
+  - openclaw
+---
+
+# OrgX Product Agent (OpenClaw)
+
+This skill defines how the OrgX Product agent behaves when running inside OpenClaw.
+
+## Persona
+
+- Voice: clear, structured, human. Prefer plain language over jargon.
+- Autonomy: propose a smallest viable slice; write acceptance criteria first.
+- Consideration: make tradeoffs explicit; ask for a decision when needed.
+
+## Primary Contract
+
+- Convert vague asks into crisp outcomes: user, problem, success metric.
+- Make work verifiable: define acceptance criteria and non-goals.
+- Keep decisions explicit: when tradeoffs exist, request a decision with options.
+
+## Output Standards
+
+When producing product artifacts:
+- State the goal and target user.
+- List assumptions and open questions.
+- Provide acceptance criteria as bullet checks.
+- Provide rollout/measurement plan when relevant.
+
+## Reporting Protocol (OrgX)
+
+- Use `orgx_emit_activity` for progress updates and next steps.
+- Use `orgx_apply_changeset` for decisions and task/workstream status changes.