fix: correct MCP SSE launch, shebang ordering, and E2E helper scripts

- execution_mixin: replace non-existent FastMCP.create_app() with the
  repo's working low-level SSE transport pattern (connect_sse +
  handle_post_message), matching mcp/mcp_server.py; normalize base_path
  leading slash. Fixes AttributeError at MCP server startup.
- examples (36 files): move '# praisonai: skip=true' below the shebang so
  direct execution still works; directive stays within the runner's
  first-30-lines scan.
- failover_example: display real 'last_error' instead of unmodeled
  'failure_count' (which always printed 0).
- scripts/apply_e2e_batch3_*.py: make skip insertion shebang-aware, wire
  the previously-uncalled fix_mcp_env_examples(), and make the E2E report
  path a CLI argument (defaulting to the audit path).

Co-authored-by: Mervin Praison <[email protected]>

.github/actions/install-monorepo-packages/action.yml

@@ -1,5 +1,5 @@
 name: Install PraisonAI monorepo packages
-description: Install praisonai-agents, praisonai-code, praisonai-bot, praisonai-train, praisonai-browser, praisonai-mcp, praisonai-sandbox, praisonai-deploy, and praisonai wrapper from local paths (mirrors PyPI nine-package install order).
+description: Install praisonai-agents, praisonai-code, praisonai-bot, praisonai-train, praisonai-browser, praisonai-mcp, praisonai-sandbox, and praisonai wrapper from local paths (mirrors PyPI eight-package install order).
 
 inputs:
   repo-root:
@@ -40,7 +40,6 @@ runs:
         BROWSER_PKG="${BASE}src/praisonai-browser"
         MCP_PKG="${BASE}src/praisonai-mcp"
         SANDBOX_PKG="${BASE}src/praisonai-sandbox"
-        DEPLOY_PKG="${BASE}src/praisonai-deploy"
         WRAPPER_PKG="${BASE}src/praisonai"
 
         normalise_extras() {
@@ -70,8 +69,6 @@ runs:
           uv pip install --system -e .
           cd "$SANDBOX_PKG"
           uv pip install --system -e .
-          cd "$DEPLOY_PKG"
-          uv pip install --system -e .
           cd "$WRAPPER_PKG"
           uv pip install --system "${WRAPPER_SUFFIX}"
         else
@@ -89,8 +86,6 @@ runs:
           pip install -e .
           cd "$SANDBOX_PKG"
           pip install -e .
-          cd "$DEPLOY_PKG"
-          pip install -e .
           cd "$WRAPPER_PKG"
           pip install -e "${WRAPPER_SUFFIX}"
         fi

.github/scripts/merge-gate.js

@@ -74,11 +74,7 @@ function isClaudeTriggerNoise(c) {
 
 function isClaudeFinalReplyComment(c) {
   const login = (c.user?.login || '').toLowerCase();
-  const fromAutomation =
-    login.includes('praisonai-triage') ||
-    login.includes('github-actions') ||
-    AUTO_ACTORS.some((a) => a.toLowerCase() === login);
-  if (!fromAutomation) return false;
+  if (!login.includes('praisonai-triage')) return false;
   return (c.body || '').includes('Claude finished');
 }
 
@@ -100,47 +96,15 @@ function isConflictRebaseTriggerComment(c) {
 
 function isConflictRebaseCompletionComment(c) {
   const login = (c.user?.login || '').toLowerCase();
-  const fromAutomation =
-    login.includes('praisonai-triage') ||
-    login.includes('github-actions') ||
-    AUTO_ACTORS.some((a) => a.toLowerCase() === login);
-  if (!fromAutomation) return false;
+  if (!login.includes('praisonai-triage') && !login.includes('github-actions')) return false;
   const body = (c.body || '').toLowerCase();
   return (
     body.includes('rebase complete') ||
     body.includes('rebase onto') ||
-    body.includes('force-pushed') ||
     (body.includes('conflict') && body.includes('resolved'))
   );
 }
 
-/** HEAD landed after conflict rebase but no FINAL @claude since that push. */
-function needsFinalReReviewAfterConflictRebase(comments, headPushedAt) {
-  if (!headPushedAt) return false;
-  const headTime = new Date(headPushedAt).getTime();
-  const conflictTriggers = comments.filter(isConflictRebaseTriggerComment);
-  if (conflictTriggers.length === 0) return false;
-
-  const latestConflict = conflictTriggers.reduce((a, b) =>
-    new Date(a.created_at) > new Date(b.created_at) ? a : b
-  );
-  const conflictTime = new Date(latestConflict.created_at).getTime();
-  if (headTime <= conflictTime) return false;
-
-  const rebaseDone = comments.some(
-    (c) =>
-      new Date(c.created_at).getTime() > conflictTime && isConflictRebaseCompletionComment(c)
-  );
-  if (!rebaseDone) return false;
-
-  const finalsAfterHead = comments.filter(
-    (c) =>
-      isFinalClaudeTriggerComment(c) &&
-      new Date(c.created_at).getTime() >= headTime - 60000
-  );
-  return finalsAfterHead.length === 0;
-}
-
 function conflictRebaseQuiescent(comments, headPushedAt) {
   const conflictTriggers = comments.filter(isConflictRebaseTriggerComment);
   if (conflictTriggers.length === 0) return true;
@@ -281,9 +245,6 @@ function shouldSkipStaleFinalRecovery(comments, headPushedAt, headPusherLogin =
   if (headPusherLogin && isClaudeAutomationLogin(headPusherLogin)) {
     return { skip: true, reason: 'head pushed by Claude automation' };
   }
-  if (needsFinalReReviewAfterConflictRebase(comments, headPushedAt)) {
-    return { skip: false, reason: '' };
-  }
   if (isPushSoonAfterLatestFinal(comments, headPushedAt)) {
     return {
       skip: true,
@@ -955,7 +916,6 @@ module.exports = {
   hasRecentConflictComment,
   isConflictRebaseTriggerComment,
   isConflictRebaseCompletionComment,
-  needsFinalReReviewAfterConflictRebase,
   conflictRebaseQuiescent,
   hasHumanChangesRequested,
   hasAnyChangesRequested,

.github/scripts/release-gate-selftest.js

@@ -11,112 +11,47 @@ assert.ok(versions.currentCode);
 assert.ok(versions.currentWrapper);
 assert.ok(versions.targetCode);
 assert.ok(rg.PACKAGE_PATHS.includes('src/praisonai-code'));
-// Every released package must make the gate's path-change check eligible.
-for (const p of [
-  'src/praisonai', 'src/praisonai-agents', 'src/praisonai-code',
-  'src/praisonai-bot', 'src/praisonai-train', 'src/praisonai-browser',
-  'src/praisonai-mcp', 'src/praisonai-sandbox', 'src/praisonai-deploy',
-]) {
-  assert.ok(rg.PACKAGE_PATHS.includes(p), `PACKAGE_PATHS missing ${p}`);
-}
 
 const noonUtc = new Date('2026-07-08T12:00:00Z');
 const dayStart = rg.utcDayStart(noonUtc);
 assert.strictEqual(dayStart.toISOString(), '2026-07-08T00:00:00.000Z');
 
-function mockGithub({ runs = [], releases = [] } = {}) {
-  return {
-    rest: {
-      actions: {
-        listWorkflowRuns: async () => ({ data: { workflow_runs: runs } }),
-      },
-      repos: {
-        listReleases: async () => ({ data: releases }),
-      },
-    },
-  };
-}
-
 (async () => {
   assert.strictEqual(await rg.pypiVersionExists('praisonaiagents', '0.0.0'), false);
 
-  assert.strictEqual(rg.PATCH_RELEASE_INTERVAL_DAYS, 3);
-
-  // Dedupe is release-based: a v* release inside the window blocks…
-  const recentRelease = mockGithub({
-    releases: [{ tag_name: 'v4.6.159', published_at: '2026-07-08T09:00:00Z' }],
-  });
+  const mockGithub = {
+    rest: {
+      actions: {
+        listWorkflowRuns: async () => ({
+          data: {
+            workflow_runs: [
+              {
+                conclusion: 'success',
+                created_at: '2026-07-08T09:00:00Z',
+                status: 'completed',
+              },
+            ],
+          },
+        }),
+      },
+    },
+  };
   assert.strictEqual(
-    await rg.hasSuccessfulReleaseWithinDays(recentRelease, 'o', 'r', noonUtc),
+    await rg.hasSuccessfulReleaseToday(mockGithub, 'o', 'r', noonUtc),
     true
   );
 
   const result = await rg.evaluateReleasePreflight(
-    recentRelease, 'o', 'r',
+    mockGithub, 'o', 'r',
     { headSha: 'abc', isCiTrigger: false, bump: 'patch', now: noonUtc },
     null
   );
-  assert.ok(result.reasons.some((r) => r.includes('every 3 days')));
-
-  // …an old release does not…
-  const oldRelease = mockGithub({
-    releases: [{ tag_name: 'v4.6.150', published_at: '2026-07-04T09:00:00Z' }],
-  });
-  assert.strictEqual(
-    await rg.hasSuccessfulReleaseWithinDays(oldRelease, 'o', 'r', noonUtc),
-    false
-  );
-
-  // …and a dry-run "success" (workflow run, no release) does not consume the
-  // window: only real releases count.
-  const dryRunOnly = mockGithub({
-    runs: [{ conclusion: 'success', created_at: '2026-07-08T09:00:00Z', status: 'completed' }],
-    releases: [],
-  });
-  assert.strictEqual(
-    await rg.hasSuccessfulReleaseWithinDays(dryRunOnly, 'o', 'r', noonUtc),
-    false
-  );
-
-  // Active-run blocking: fresh waiting run blocks…
-  const freshWaiting = mockGithub({
-    runs: [{ status: 'waiting', conclusion: null, created_at: '2026-07-08T11:00:00Z', html_url: 'x' }],
-  });
-  assert.strictEqual(
-    await rg.hasActiveReleaseRun(freshWaiting, 'o', 'r', noonUtc, null),
-    true
-  );
-
-  // …a waiting run stuck longer than STALE_WAITING_HOURS no longer blocks…
-  const staleWaiting = mockGithub({
-    runs: [{ status: 'waiting', conclusion: null, created_at: '2026-07-08T01:00:00Z', html_url: 'x' }],
-  });
-  const warnings = [];
-  const fakeCore = { warning: (m) => warnings.push(m), info: () => {} };
-  assert.strictEqual(rg.STALE_WAITING_HOURS, 6);
-  assert.strictEqual(
-    await rg.hasActiveReleaseRun(staleWaiting, 'o', 'r', noonUtc, fakeCore),
-    false
-  );
-  assert.ok(warnings.length === 1 && warnings[0].includes('approve or cancel'));
-
-  // …but an in_progress run always blocks regardless of age.
-  const oldInProgress = mockGithub({
-    runs: [{ status: 'in_progress', conclusion: null, created_at: '2026-07-07T01:00:00Z', html_url: 'x' }],
-  });
-  assert.strictEqual(
-    await rg.hasActiveReleaseRun(oldInProgress, 'o', 'r', noonUtc, null),
-    true
-  );
+  assert.ok(result.reasons.some((r) => r.includes('already released today')));
 
   console.log('ok: bumpPatch');
   console.log('ok: readVersionsFromTree');
-  console.log('ok: PACKAGE_PATHS covers all 9 released packages');
   console.log('ok: pypiVersionExists missing version');
   console.log('ok: utcDayStart');
-  console.log('ok: release-based dedupe (recent blocks, old does not)');
-  console.log('ok: dry-run success does not consume the release window');
-  console.log('ok: 3-day dedupe blocks second release');
-  console.log('ok: fresh waiting run blocks; stale waiting run ignored with warning');
-  console.log('ok: in_progress always blocks');
+  console.log('ok: hasSuccessfulReleaseToday');
+  console.log('ok: daily dedupe blocks second release');
 })();

.github/scripts/release-gate.js

@@ -4,31 +4,10 @@
 
 const https = require('https');
 
-/** Every directory whose changes should make a release eligible — all nine
- * published packages (mirrors the skip_* inputs in pypi-release.yml). */
-const PACKAGE_PATHS = [
-  'src/praisonai',
-  'src/praisonai-agents',
-  'src/praisonai-code',
-  'src/praisonai-bot',
-  'src/praisonai-train',
-  'src/praisonai-browser',
-  'src/praisonai-mcp',
-  'src/praisonai-sandbox',
-  'src/praisonai-deploy',
-];
-/** Minimum days between successful patch auto-releases. */
-const PATCH_RELEASE_INTERVAL_DAYS = 3;
+const PACKAGE_PATHS = ['src/praisonai', 'src/praisonai-agents', 'src/praisonai-code'];
 const ACTIVE_RELEASE_STATUSES = new Set([
   'queued', 'in_progress', 'waiting', 'pending', 'requested',
 ]);
-/** A run stuck in `waiting` (environment approval) longer than this no longer
- * blocks the gate. GitHub only auto-fails unapproved deployments after 30
- * days, so without a cutoff one forgotten manual dispatch stalls all
- * auto-releases for up to a month. The run is warned about, never cancelled —
- * if later approved, the pypi-release concurrency group serializes it and its
- * pypi_exists checks no-op anything already published. */
-const STALE_WAITING_HOURS = 6;
 
 function bumpPatch(version) {
   const parts = version.split('.');
@@ -84,65 +63,36 @@ function pypiVersionExists(packageName, version) {
   });
 }
 
-async function hasActiveReleaseRun(github, owner, repo, now = new Date(), core = null) {
+async function hasActiveReleaseRun(github, owner, repo) {
   const runs = await github.rest.actions.listWorkflowRuns({
     owner,
     repo,
     workflow_id: 'pypi-release.yml',
     per_page: 20,
   });
-  const staleCutoff = now.getTime() - STALE_WAITING_HOURS * 60 * 60 * 1000;
-  return runs.data.workflow_runs.some((r) => {
-    if (!ACTIVE_RELEASE_STATUSES.has(r.status) || r.conclusion) return false;
-    if (r.status === 'waiting' && new Date(r.created_at).getTime() < staleCutoff) {
-      if (core) {
-        core.warning(
-          `Ignoring release run waiting >${STALE_WAITING_HOURS}h for environment approval: `
-          + `${r.html_url} — approve or cancel it. It no longer blocks auto-releases.`
-        );
-      }
-      return false;
-    }
-    return true;
-  });
+  return runs.data.workflow_runs.some(
+    (r) => ACTIVE_RELEASE_STATUSES.has(r.status) && !r.conclusion
+  );
 }
 
 function utcDayStart(now = new Date()) {
   return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
 }
 
-function releaseIntervalStart(now = new Date(), intervalDays = PATCH_RELEASE_INTERVAL_DAYS) {
-  return new Date(now.getTime() - intervalDays * 24 * 60 * 60 * 1000);
-}
-
-async function hasSuccessfulReleaseWithinDays(
-  github,
-  owner,
-  repo,
-  now = new Date(),
-  intervalDays = PATCH_RELEASE_INTERVAL_DAYS,
-) {
-  const windowStart = releaseIntervalStart(now, intervalDays);
-  // Dedupe on GitHub releases (v* tags) rather than run conclusions: a
-  // dry_run=true dispatch concludes 'success' without publishing anything and
-  // must not consume the release window. Only a real full release creates a
-  // v* GitHub release (bump_and_release.py's `gh release create`).
-  const releases = await github.rest.repos.listReleases({
+async function hasSuccessfulReleaseToday(github, owner, repo, now = new Date()) {
+  const dayStart = utcDayStart(now);
+  const runs = await github.rest.actions.listWorkflowRuns({
     owner,
     repo,
-    per_page: 10,
+    workflow_id: 'pypi-release.yml',
+    status: 'completed',
+    per_page: 30,
   });
-  return releases.data.some(
-    (r) => r.tag_name && r.tag_name.startsWith('v')
-      && new Date(r.published_at || r.created_at) >= windowStart
+  return runs.data.workflow_runs.some(
+    (r) => r.conclusion === 'success' && new Date(r.created_at) >= dayStart
   );
 }
 
-/** @deprecated Use hasSuccessfulReleaseWithinDays — kept for selftests. */
-async function hasSuccessfulReleaseToday(github, owner, repo, now = new Date()) {
-  return hasSuccessfulReleaseWithinDays(github, owner, repo, now, 1);
-}
-
 async function lastGreenCoreTestsSha(github, owner, repo) {
   const runs = await github.rest.actions.listWorkflowRuns({
     owner,
@@ -179,18 +129,15 @@ async function evaluateReleasePreflight(github, owner, repo, options, core) {
     return out;
   }
 
-  const referenceTime = options.now instanceof Date ? options.now : new Date();
-
-  if (await hasActiveReleaseRun(github, owner, repo, referenceTime, core)) {
+  if (await hasActiveReleaseRun(github, owner, repo)) {
     reasons.push('PyPI Release already in progress or awaiting approval');
     return out;
   }
 
-  if (await hasSuccessfulReleaseWithinDays(github, owner, repo, referenceTime)) {
-    reasons.push(
-      `already released within last ${PATCH_RELEASE_INTERVAL_DAYS} days; `
-      + `max one patch release every ${PATCH_RELEASE_INTERVAL_DAYS} days`
-    );
+  const referenceTime = options.now instanceof Date ? options.now : new Date();
+  if (await hasSuccessfulReleaseToday(github, owner, repo, referenceTime)) {
+    const day = referenceTime.toISOString().slice(0, 10);
+    reasons.push(`already released today (UTC ${day}); max one patch release per day`);
     return out;
   }
 
@@ -260,35 +207,8 @@ async function evaluateReleasePreflight(github, owner, repo, options, core) {
     out.headSha = evalSha;
     const greenSha = await lastGreenCoreTestsSha(github, owner, repo);
     if (greenSha !== evalSha) {
-      // Core Tests has path filters and honors [skip ci] (the release
-      // safety-net commit uses it), so the tip of main may legitimately have
-      // no Core Tests run of its own — e.g. a docs-only commit, or the
-      // "chore(release): … [skip ci]" commit right after a release. Accept a
-      // green ancestor when nothing under the released package paths changed
-      // after it; otherwise the cron path stalls until the next src/** push.
-      let greenAncestorOk = false;
-      if (greenSha && /^[0-9a-f]{40}$/.test(greenSha)) {
-        try {
-          execSync(`git merge-base --is-ancestor ${greenSha} ${evalSha}`);
-          const delta = execSync(
-            `git diff --name-only ${greenSha} ${evalSha} -- ${PACKAGE_PATHS.join(' ')}`,
-            { encoding: 'utf8' }
-          ).trim();
-          greenAncestorOk = delta === '';
-        } catch {
-          greenAncestorOk = false;
-        }
-      }
-      if (!greenAncestorOk) {
-        reasons.push(`CI not green on HEAD (last green: ${greenSha ? greenSha.slice(0, 7) : 'none'})`);
-        return out;
-      }
-      if (core) {
-        core.info(
-          `HEAD ${evalSha.slice(0, 7)} has no Core Tests run; accepting green ancestor `
-          + `${greenSha.slice(0, 7)} (no package-path changes since).`
-        );
-      }
+      reasons.push(`CI not green on HEAD (last green: ${greenSha ? greenSha.slice(0, 7) : 'none'})`);
+      return out;
     }
   }
 
@@ -302,11 +222,6 @@ module.exports = {
   bumpPatch,
   readVersionsFromTree,
   pypiVersionExists,
-  PATCH_RELEASE_INTERVAL_DAYS,
-  STALE_WAITING_HOURS,
-  releaseIntervalStart,
-  hasActiveReleaseRun,
-  hasSuccessfulReleaseWithinDays,
   hasSuccessfulReleaseToday,
   utcDayStart,
   evaluateReleasePreflight,

.github/workflows/nightly-release-gate.yml

@@ -1,12 +1,12 @@
 name: Nightly Release Gate
 
 # Preflight before PyPI Release (patch bump).
-# Triggers: Core Tests success on main (workflow_run) or cron every 3 days at 00:00 UTC.
-# Dedupe: max one successful patch release every 3 days (see release-gate.js).
+# Triggers: Core Tests success on main (workflow_run) or nightly cron at 00:00 UTC.
+# Dedupe: max one successful patch release per UTC day (see release-gate.js).
 
 on:
   schedule:
-    - cron: '0 0 */3 * *'
+    - cron: '0 0 * * *'
   workflow_dispatch:
     inputs:
       dry_run:
@@ -41,7 +41,7 @@ jobs:
         github.event.workflow_run.head_branch == 'main' &&
         github.event.workflow_run.event == 'push' &&
         !startsWith(github.event.workflow_run.head_commit.message, 'Release v') &&
-        !startsWith(github.event.workflow_run.head_commit.message, 'chore(release):')
+        !startsWith(github.event.workflow_run.head_commit.message, 'Bump praisonai')
       )
     runs-on: ubuntu-latest
     env:
@@ -69,10 +69,6 @@ jobs:
       - name: Fetch main and tags
         run: git fetch --tags origin main
 
-      # Guards the gate logic itself — no workflow ran these selftests before.
-      - name: Selftest release-gate script
-        run: node .github/scripts/release-gate-selftest.js
-
       - name: Preflight — path changes, CI SHA, dedupe
         id: preflight
         uses: actions/github-script@v7

.github/workflows/pypi-release.yml

@@ -61,29 +61,6 @@ on:
         required: false
         default: false
         type: boolean
-      skip_deploy:
-        description: 'Skip praisonai-deploy publish (recovery if already on PyPI)'
-        required: false
-        default: false
-        type: boolean
-      # NOTE: GitHub caps workflow_dispatch at 25 top-level inputs; this
-      # workflow has 23. Adding a 10th package (skip_* + *_version) hits 25.
-      only:
-        description: 'Release ONLY this package (forces skip on all others); all = no restriction'
-        required: false
-        default: all
-        type: choice
-        options:
-          - all
-          - agents
-          - code
-          - bot
-          - train
-          - browser
-          - mcp
-          - sandbox
-          - deploy
-          - wrapper
       agents_version:
         description: 'Override agents version (empty = auto bump from pyproject.toml)'
         required: false
@@ -124,11 +101,6 @@ on:
         required: false
         default: ''
         type: string
-      deploy_version:
-        description: 'Override praisonai-deploy version (empty = auto bump from pyproject.toml)'
-        required: false
-        default: ''
-        type: string
       source:
         description: 'Trigger source (audit trail)'
         required: false
@@ -162,35 +134,15 @@ jobs:
         'pypi-auto' || 'pypi'
       }}
     env:
-      # PyPI API token auth: username __token__, password = pypi-… token (see pypi.org/help/#invalid-auth)
-      UV_PUBLISH_USERNAME: __token__
-      UV_PUBLISH_PASSWORD: ${{ secrets.PYPI_TOKEN || secrets.PYPI_API_TOKEN }}
-      # GH_TOKEN is NOT set here: it is a GitHub App installation token minted in
-      # "Generate GitHub App token" and exported via $GITHUB_ENV, so releases are
-      # authored by praisonai-triage-agent[bot] rather than MervinPraison.
+      UV_PUBLISH_TOKEN: ${{ secrets.PYPI_TOKEN || secrets.PYPI_API_TOKEN }}
+      GH_TOKEN: ${{ secrets.GH_TOKEN }}
     steps:
-      - name: Generate GitHub App token
-        id: app-token
-        uses: actions/create-github-app-token@v1
-        with:
-          app-id: ${{ secrets.CLAUDE_APP_ID }}
-          private-key: ${{ secrets.CLAUDE_APP_PRIVATE_KEY }}
-          owner: ${{ github.repository_owner }}
-          # Scope to this repo only. Without it the token is minted for every
-          # repository the owner has; this job never leaves PraisonAI (checkout,
-          # push to origin, and gh release create all target it).
-          repositories: ${{ github.event.repository.name }}
-
       - name: Checkout main
         uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5  # v4
         with:
           ref: main
           fetch-depth: 0
-          token: ${{ steps.app-token.outputs.token }}
-          # Do not bake the token into .git/config: an http.extraheader would
-          # outrank the remote URL set in "Configure git" and pin this first
-          # (1h) token, defeating the refresh before the wrapper release.
-          persist-credentials: false
+          token: ${{ secrets.GH_TOKEN }}
 
       - name: Set up Python
         uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065  # v5
@@ -201,19 +153,10 @@ jobs:
         uses: astral-sh/setup-uv@38f3f104447c67c051c4a08e39b64a148898af3a  # v4
 
       - name: Configure git
-        env:
-          APP_TOKEN: ${{ steps.app-token.outputs.token }}
-          REPO: ${{ github.repository }}
         run: |
-          set -euo pipefail
-          git config user.name "praisonai-triage-agent[bot]"
-          git config user.email "272766704+praisonai-triage-agent[bot]@users.noreply.github.com"
-          # persist-credentials:false left the remote unauthenticated; push auth
-          # comes from the app token embedded here (masked in logs, and the
-          # token dies with the runner).
-          git remote set-url origin "https://x-access-token:${APP_TOKEN}@github.com/${REPO}.git"
-          echo "GH_TOKEN=${APP_TOKEN}" >> "$GITHUB_ENV"
-          GH_TOKEN="${APP_TOKEN}" gh auth setup-git
+          git config user.name "MervinPraison"
+          git config user.email "[email protected]"
+          gh auth setup-git
 
       - name: Release summary
         run: |
@@ -223,36 +166,6 @@ jobs:
           echo "Dry run: ${{ inputs.dry_run }}"
           echo "Environment: ${{ (inputs.source == 'ci' || inputs.source == 'nightly') && inputs.bump == 'patch' && 'pypi-auto' || 'pypi' }}"
 
-      # Single source of truth for which packages this run releases. `only`
-      # inverts into the skip flags here; everything downstream (version
-      # computation, PyPI detection, publish conditions) consumes these
-      # outputs, so a dedicated one-package release is one input instead of
-      # eight skip flags.
-      - name: Resolve effective skips
-        id: flags
-        env:
-          ONLY: ${{ inputs.only }}
-          SKIP_AGENTS: ${{ inputs.skip_agents }}
-          SKIP_CODE: ${{ inputs.skip_code }}
-          SKIP_BOT: ${{ inputs.skip_bot }}
-          SKIP_TRAIN: ${{ inputs.skip_train }}
-          SKIP_BROWSER: ${{ inputs.skip_browser }}
-          SKIP_MCP: ${{ inputs.skip_mcp }}
-          SKIP_SANDBOX: ${{ inputs.skip_sandbox }}
-          SKIP_DEPLOY: ${{ inputs.skip_deploy }}
-          SKIP_WRAPPER: ${{ inputs.skip_wrapper }}
-        run: |
-          set -euo pipefail
-          for pkg in agents code bot train browser mcp sandbox deploy wrapper; do
-            var="SKIP_$(echo "$pkg" | tr '[:lower:]' '[:upper:]')"
-            skip="${!var}"
-            if [ -n "${ONLY}" ] && [ "${ONLY}" != "all" ] && [ "${ONLY}" != "$pkg" ]; then
-              skip=true
-            fi
-            echo "skip_${pkg}=${skip}" >> "$GITHUB_OUTPUT"
-            echo "skip_${pkg}=${skip}"
-          done
-
       - name: Compute release versions
         id: versions
         env:
@@ -265,15 +178,13 @@ jobs:
           BROWSER_OVERRIDE: ${{ inputs.browser_version }}
           MCP_OVERRIDE: ${{ inputs.mcp_version }}
           SANDBOX_OVERRIDE: ${{ inputs.sandbox_version }}
-          DEPLOY_OVERRIDE: ${{ inputs.deploy_version }}
-          SKIP_AGENTS: ${{ steps.flags.outputs.skip_agents }}
-          SKIP_CODE: ${{ steps.flags.outputs.skip_code }}
-          SKIP_BOT: ${{ steps.flags.outputs.skip_bot }}
-          SKIP_TRAIN: ${{ steps.flags.outputs.skip_train }}
-          SKIP_BROWSER: ${{ steps.flags.outputs.skip_browser }}
-          SKIP_MCP: ${{ steps.flags.outputs.skip_mcp }}
-          SKIP_SANDBOX: ${{ steps.flags.outputs.skip_sandbox }}
-          SKIP_DEPLOY: ${{ steps.flags.outputs.skip_deploy }}
+          SKIP_AGENTS: ${{ inputs.skip_agents }}
+          SKIP_CODE: ${{ inputs.skip_code }}
+          SKIP_BOT: ${{ inputs.skip_bot }}
+          SKIP_TRAIN: ${{ inputs.skip_train }}
+          SKIP_BROWSER: ${{ inputs.skip_browser }}
+          SKIP_MCP: ${{ inputs.skip_mcp }}
+          SKIP_SANDBOX: ${{ inputs.skip_sandbox }}
         run: |
           python <<'PY'
           import os
@@ -310,7 +221,6 @@ jobs:
           browser_override = os.environ.get("BROWSER_OVERRIDE", "").strip()
           mcp_override = os.environ.get("MCP_OVERRIDE", "").strip()
           sandbox_override = os.environ.get("SANDBOX_OVERRIDE", "").strip()
-          deploy_override = os.environ.get("DEPLOY_OVERRIDE", "").strip()
           validate_version("agents_version", agents_override)
           validate_version("wrapper_version", wrapper_override)
           validate_version("code_version", code_override)
@@ -319,7 +229,6 @@ jobs:
           validate_version("browser_version", browser_override)
           validate_version("mcp_version", mcp_override)
           validate_version("sandbox_version", sandbox_override)
-          validate_version("deploy_version", deploy_override)
 
           agents_pyproject = root / "src/praisonai-agents/pyproject.toml"
           agents_content = agents_pyproject.read_text()
@@ -377,14 +286,6 @@ jobs:
               sys.exit(1)
           current_sandbox = sandbox_match.group(1)
 
-          deploy_pyproject = root / "src/praisonai-deploy/pyproject.toml"
-          deploy_content = deploy_pyproject.read_text()
-          deploy_match = re.search(r'^version\s*=\s*"([^"]+)"', deploy_content, re.MULTILINE)
-          if not deploy_match:
-              print("Could not read praisonai-deploy version from pyproject.toml", file=sys.stderr)
-              sys.exit(1)
-          current_deploy = deploy_match.group(1)
-
           wrapper_version_py = root / "src/praisonai/praisonai/version.py"
           wrapper_content = wrapper_version_py.read_text()
           wrapper_match = re.search(r'__version__ = "([^"]+)"', wrapper_content)
@@ -401,7 +302,6 @@ jobs:
               ("browser", current_browser),
               ("mcp", current_mcp),
               ("sandbox", current_sandbox),
-              ("deploy", current_deploy),
               ("wrapper", current_wrapper),
           ):
               if not SEMVER.match(value):
@@ -415,7 +315,6 @@ jobs:
           skip_browser = os.environ.get("SKIP_BROWSER", "false").lower() == "true"
           skip_mcp = os.environ.get("SKIP_MCP", "false").lower() == "true"
           skip_sandbox = os.environ.get("SKIP_SANDBOX", "false").lower() == "true"
-          skip_deploy = os.environ.get("SKIP_DEPLOY", "false").lower() == "true"
 
           if agents_override:
               agents_version = agents_override
@@ -466,13 +365,6 @@ jobs:
           else:
               sandbox_version = bump_version(current_sandbox)
 
-          if deploy_override:
-              deploy_version = deploy_override
-          elif skip_deploy:
-              deploy_version = current_deploy
-          else:
-              deploy_version = bump_version(current_deploy)
-
           if wrapper_override:
               wrapper_version = wrapper_override
           else:
@@ -487,7 +379,6 @@ jobs:
               fh.write(f"browser_version={browser_version}\n")
               fh.write(f"mcp_version={mcp_version}\n")
               fh.write(f"sandbox_version={sandbox_version}\n")
-              fh.write(f"deploy_version={deploy_version}\n")
               fh.write(f"wrapper_version={wrapper_version}\n")
               fh.write(f"current_agents={current_agents}\n")
               fh.write(f"current_code={current_code}\n")
@@ -496,7 +387,6 @@ jobs:
               fh.write(f"current_browser={current_browser}\n")
               fh.write(f"current_mcp={current_mcp}\n")
               fh.write(f"current_sandbox={current_sandbox}\n")
-              fh.write(f"current_deploy={current_deploy}\n")
               fh.write(f"current_wrapper={current_wrapper}\n")
 
           print(f"Agents:  {current_agents} -> {agents_version}")
@@ -506,7 +396,6 @@ jobs:
           print(f"Browser: {current_browser} -> {browser_version}")
           print(f"MCP:     {current_mcp} -> {mcp_version}")
           print(f"Sandbox: {current_sandbox} -> {sandbox_version}")
-          print(f"Deploy:  {current_deploy} -> {deploy_version}")
           print(f"Wrapper: {current_wrapper} -> {wrapper_version}")
           PY
 
@@ -521,17 +410,15 @@ jobs:
           BROWSER_VERSION: ${{ steps.versions.outputs.browser_version }}
           MCP_VERSION: ${{ steps.versions.outputs.mcp_version }}
           SANDBOX_VERSION: ${{ steps.versions.outputs.sandbox_version }}
-          DEPLOY_VERSION: ${{ steps.versions.outputs.deploy_version }}
           WRAPPER_VERSION: ${{ steps.versions.outputs.wrapper_version }}
-          INPUT_SKIP_AGENTS: ${{ steps.flags.outputs.skip_agents }}
-          INPUT_SKIP_CODE: ${{ steps.flags.outputs.skip_code }}
-          INPUT_SKIP_BOT: ${{ steps.flags.outputs.skip_bot }}
-          INPUT_SKIP_TRAIN: ${{ steps.flags.outputs.skip_train }}
-          INPUT_SKIP_BROWSER: ${{ steps.flags.outputs.skip_browser }}
-          INPUT_SKIP_MCP: ${{ steps.flags.outputs.skip_mcp }}
-          INPUT_SKIP_SANDBOX: ${{ steps.flags.outputs.skip_sandbox }}
-          INPUT_SKIP_DEPLOY: ${{ steps.flags.outputs.skip_deploy }}
-          INPUT_SKIP_WRAPPER: ${{ steps.flags.outputs.skip_wrapper }}
+          INPUT_SKIP_AGENTS: ${{ inputs.skip_agents }}
+          INPUT_SKIP_CODE: ${{ inputs.skip_code }}
+          INPUT_SKIP_BOT: ${{ inputs.skip_bot }}
+          INPUT_SKIP_TRAIN: ${{ inputs.skip_train }}
+          INPUT_SKIP_BROWSER: ${{ inputs.skip_browser }}
+          INPUT_SKIP_MCP: ${{ inputs.skip_mcp }}
+          INPUT_SKIP_SANDBOX: ${{ inputs.skip_sandbox }}
+          INPUT_SKIP_WRAPPER: ${{ inputs.skip_wrapper }}
         run: |
           set -euo pipefail
           skip_agents="${INPUT_SKIP_AGENTS}"
@@ -541,53 +428,30 @@ jobs:
           skip_browser="${INPUT_SKIP_BROWSER}"
           skip_mcp="${INPUT_SKIP_MCP}"
           skip_sandbox="${INPUT_SKIP_SANDBOX}"
-          skip_deploy="${INPUT_SKIP_DEPLOY}"
           skip_wrapper="${INPUT_SKIP_WRAPPER}"
-          # Returns 0 if published, 1 if definitively absent (404). Any other
-          # HTTP status (PyPI outage, 5xx, rate limit) FAILS the run: guessing
-          # "not published" would lead to a duplicate-upload failure midway
-          # through the release, which is strictly worse than stopping here
-          # before anything has been published.
-          pypi_published() { # $1=package $2=version
-            local code attempt
-            for attempt in 1 2 3; do
-              code=$(curl -s -o /dev/null -w '%{http_code}' --max-time 30 \
-                "https://pypi.org/pypi/$1/$2/json" || echo "000")
-              case "$code" in
-                200) return 0 ;;
-                404) return 1 ;;
-                *) echo "PyPI check $1==$2 returned HTTP ${code} (attempt ${attempt}/3)"; sleep 5 ;;
-              esac
-            done
-            echo "❌ Cannot determine PyPI state for $1==$2; refusing to guess." >&2
-            exit 2
-          }
           if [ "$skip_agents" != "true" ]; then
-            pypi_published praisonaiagents "${AGENTS_VERSION}" && skip_agents=true || true
+            curl -fsSL "https://pypi.org/pypi/praisonaiagents/${AGENTS_VERSION}/json" >/dev/null && skip_agents=true || true
           fi
           if [ "$skip_code" != "true" ]; then
-            pypi_published praisonai-code "${CODE_VERSION}" && skip_code=true || true
+            curl -fsSL "https://pypi.org/pypi/praisonai-code/${CODE_VERSION}/json" >/dev/null && skip_code=true || true
           fi
           if [ "$skip_bot" != "true" ]; then
-            pypi_published praisonai-bot "${BOT_VERSION}" && skip_bot=true || true
+            curl -fsSL "https://pypi.org/pypi/praisonai-bot/${BOT_VERSION}/json" >/dev/null && skip_bot=true || true
           fi
           if [ "$skip_train" != "true" ]; then
-            pypi_published praisonai-train "${TRAIN_VERSION}" && skip_train=true || true
+            curl -fsSL "https://pypi.org/pypi/praisonai-train/${TRAIN_VERSION}/json" >/dev/null && skip_train=true || true
           fi
           if [ "$skip_browser" != "true" ]; then
-            pypi_published praisonai-browser "${BROWSER_VERSION}" && skip_browser=true || true
+            curl -fsSL "https://pypi.org/pypi/praisonai-browser/${BROWSER_VERSION}/json" >/dev/null && skip_browser=true || true
           fi
           if [ "$skip_mcp" != "true" ]; then
-            pypi_published praisonai-mcp "${MCP_VERSION}" && skip_mcp=true || true
+            curl -fsSL "https://pypi.org/pypi/praisonai-mcp/${MCP_VERSION}/json" >/dev/null && skip_mcp=true || true
           fi
           if [ "$skip_sandbox" != "true" ]; then
-            pypi_published praisonai-sandbox "${SANDBOX_VERSION}" && skip_sandbox=true || true
-          fi
-          if [ "$skip_deploy" != "true" ]; then
-            pypi_published praisonai-deploy "${DEPLOY_VERSION}" && skip_deploy=true || true
+            curl -fsSL "https://pypi.org/pypi/praisonai-sandbox/${SANDBOX_VERSION}/json" >/dev/null && skip_sandbox=true || true
           fi
           if [ "$skip_wrapper" != "true" ]; then
-            pypi_published praisonai "${WRAPPER_VERSION}" && skip_wrapper=true || true
+            curl -fsSL "https://pypi.org/pypi/praisonai/${WRAPPER_VERSION}/json" >/dev/null && skip_wrapper=true || true
           fi
           echo "skip_agents=${skip_agents}" >> "$GITHUB_OUTPUT"
           echo "skip_code=${skip_code}" >> "$GITHUB_OUTPUT"
@@ -596,9 +460,8 @@ jobs:
           echo "skip_browser=${skip_browser}" >> "$GITHUB_OUTPUT"
           echo "skip_mcp=${skip_mcp}" >> "$GITHUB_OUTPUT"
           echo "skip_sandbox=${skip_sandbox}" >> "$GITHUB_OUTPUT"
-          echo "skip_deploy=${skip_deploy}" >> "$GITHUB_OUTPUT"
           echo "skip_wrapper=${skip_wrapper}" >> "$GITHUB_OUTPUT"
-          if [ "$skip_agents" = "true" ] && [ "$skip_code" = "true" ] && [ "$skip_bot" = "true" ] && [ "$skip_train" = "true" ] && [ "$skip_browser" = "true" ] && [ "$skip_mcp" = "true" ] && [ "$skip_sandbox" = "true" ] && [ "$skip_deploy" = "true" ] && [ "$skip_wrapper" = "true" ]; then
+          if [ "$skip_agents" = "true" ] && [ "$skip_code" = "true" ] && [ "$skip_bot" = "true" ] && [ "$skip_train" = "true" ] && [ "$skip_browser" = "true" ] && [ "$skip_mcp" = "true" ] && [ "$skip_sandbox" = "true" ] && [ "$skip_wrapper" = "true" ]; then
             echo "All target versions already on PyPI — nothing to publish."
           fi
 
@@ -612,7 +475,6 @@ jobs:
           steps.pypi_exists.outputs.skip_browser == 'true' &&
           steps.pypi_exists.outputs.skip_mcp == 'true' &&
           steps.pypi_exists.outputs.skip_sandbox == 'true' &&
-          steps.pypi_exists.outputs.skip_deploy == 'true' &&
           steps.pypi_exists.outputs.skip_wrapper == 'true'
         run: echo "Idempotent skip — target versions already on PyPI."
 
@@ -620,43 +482,34 @@ jobs:
         if: inputs.dry_run
         run: |
           echo "Dry run — no publish, commit, or push."
-          echo "Only:            ${{ inputs.only }}"
           echo "Agents version:  ${{ steps.versions.outputs.agents_version }}"
           echo "Code version:    ${{ steps.versions.outputs.code_version }}"
           echo "Bot version:     ${{ steps.versions.outputs.bot_version }}"
           echo "Train version:   ${{ steps.versions.outputs.train_version }}"
           echo "Browser version: ${{ steps.versions.outputs.browser_version }}"
           echo "MCP version:     ${{ steps.versions.outputs.mcp_version }}"
-          echo "Sandbox version: ${{ steps.versions.outputs.sandbox_version }}"
-          echo "Deploy version:  ${{ steps.versions.outputs.deploy_version }}"
           echo "Wrapper version: ${{ steps.versions.outputs.wrapper_version }}"
           echo ""
-          if [ "${{ steps.flags.outputs.skip_agents }}" != "true" ]; then
+          if [ "${{ inputs.skip_agents }}" != "true" ]; then
             echo "Would publish praisonaiagents ${{ steps.versions.outputs.agents_version }}"
           fi
-          if [ "${{ steps.flags.outputs.skip_code }}" != "true" ]; then
+          if [ "${{ inputs.skip_code }}" != "true" ]; then
             echo "Would publish praisonai-code ${{ steps.versions.outputs.code_version }}"
           fi
-          if [ "${{ steps.flags.outputs.skip_bot }}" != "true" ]; then
+          if [ "${{ inputs.skip_bot }}" != "true" ]; then
             echo "Would publish praisonai-bot ${{ steps.versions.outputs.bot_version }}"
           fi
-          if [ "${{ steps.flags.outputs.skip_train }}" != "true" ]; then
+          if [ "${{ inputs.skip_train }}" != "true" ]; then
             echo "Would publish praisonai-train ${{ steps.versions.outputs.train_version }}"
           fi
-          if [ "${{ steps.flags.outputs.skip_browser }}" != "true" ]; then
+          if [ "${{ inputs.skip_browser }}" != "true" ]; then
             echo "Would publish praisonai-browser ${{ steps.versions.outputs.browser_version }}"
           fi
-          if [ "${{ steps.flags.outputs.skip_mcp }}" != "true" ]; then
+          if [ "${{ inputs.skip_mcp }}" != "true" ]; then
             echo "Would publish praisonai-mcp ${{ steps.versions.outputs.mcp_version }}"
           fi
-          if [ "${{ steps.flags.outputs.skip_sandbox }}" != "true" ]; then
-            echo "Would publish praisonai-sandbox ${{ steps.versions.outputs.sandbox_version }}"
-          fi
-          if [ "${{ steps.flags.outputs.skip_deploy }}" != "true" ]; then
-            echo "Would publish praisonai-deploy ${{ steps.versions.outputs.deploy_version }}"
-          fi
-          if [ "${{ steps.flags.outputs.skip_wrapper }}" != "true" ]; then
-            echo "Would run bump_and_release.py ${{ steps.versions.outputs.wrapper_version }} --agents ${{ steps.versions.outputs.agents_version }} --code-pin ${{ steps.versions.outputs.code_version }} --bot-pin ${{ steps.versions.outputs.bot_version }} --train-pin ${{ steps.versions.outputs.train_version }} --browser-pin ${{ steps.versions.outputs.browser_version }} --mcp-pin ${{ steps.versions.outputs.mcp_version }} --sandbox-pin ${{ steps.versions.outputs.sandbox_version }} --deploy-pin ${{ steps.versions.outputs.deploy_version }}"
+          if [ "${{ inputs.skip_wrapper }}" != "true" ]; then
+            echo "Would run bump_and_release.py ${{ steps.versions.outputs.wrapper_version }} --agents ${{ steps.versions.outputs.agents_version }} --code-pin ${{ steps.versions.outputs.code_version }} --bot-pin ${{ steps.versions.outputs.bot_version }} --train-pin ${{ steps.versions.outputs.train_version }} --browser-pin ${{ steps.versions.outputs.browser_version }} --mcp-pin ${{ steps.versions.outputs.mcp_version }}"
             echo "Would uv publish praisonai ${{ steps.versions.outputs.wrapper_version }}"
           fi
 
@@ -684,9 +537,7 @@ jobs:
           rm -rf dist
           uv lock
           uv build
-          # --check-url makes re-uploads idempotent: files already on PyPI are
-          # skipped instead of failing the publish (partial-upload recovery).
-          uv publish --check-url https://pypi.org/simple/
+          uv publish
 
       - name: Wait for praisonaiagents on PyPI
         if: >-
@@ -715,6 +566,19 @@ jobs:
             sleep "$INTERVAL"
           done
 
+      - name: Commit agents version bump
+        if: >-
+          inputs.dry_run != true &&
+          inputs.skip_agents != true &&
+          steps.pypi_exists.outputs.skip_agents != 'true'
+        run: |
+          set -euo pipefail
+          git add src/praisonai-agents/pyproject.toml src/praisonai-agents/uv.lock
+          git diff --cached --quiet && { echo "No agents files to commit"; exit 0; }
+          git commit -m "Bump praisonaiagents to ${{ steps.versions.outputs.agents_version }}"
+          git pull --rebase origin main
+          git push origin main
+
       - name: Publish praisonai-code
         if: >-
           inputs.dry_run != true &&
@@ -743,9 +607,7 @@ jobs:
           rm -rf dist
           uv lock
           uv build
-          # --check-url makes re-uploads idempotent: files already on PyPI are
-          # skipped instead of failing the publish (partial-upload recovery).
-          uv publish --check-url https://pypi.org/simple/
+          uv publish
 
       - name: Wait for praisonai-code on PyPI
         if: >-
@@ -774,6 +636,19 @@ jobs:
             sleep "$INTERVAL"
           done
 
+      - name: Commit praisonai-code version bump
+        if: >-
+          inputs.dry_run != true &&
+          inputs.skip_code != true &&
+          steps.pypi_exists.outputs.skip_code != 'true'
+        run: |
+          set -euo pipefail
+          git add src/praisonai-code/pyproject.toml src/praisonai-code/uv.lock src/praisonai-code/praisonai_code/__init__.py
+          git diff --cached --quiet && { echo "No code files to commit"; exit 0; }
+          git commit -m "Bump praisonai-code to ${{ steps.versions.outputs.code_version }}"
+          git pull --rebase origin main
+          git push origin main
+
       - name: Publish praisonai-bot
         if: >-
           inputs.dry_run != true &&
@@ -802,9 +677,7 @@ jobs:
           rm -rf dist
           uv lock
           uv build
-          # --check-url makes re-uploads idempotent: files already on PyPI are
-          # skipped instead of failing the publish (partial-upload recovery).
-          uv publish --check-url https://pypi.org/simple/
+          uv publish
 
       - name: Wait for praisonai-bot on PyPI
         if: >-
@@ -833,6 +706,19 @@ jobs:
             sleep "$INTERVAL"
           done
 
+      - name: Commit praisonai-bot version bump
+        if: >-
+          inputs.dry_run != true &&
+          inputs.skip_bot != true &&
+          steps.pypi_exists.outputs.skip_bot != 'true'
+        run: |
+          set -euo pipefail
+          git add src/praisonai-bot/pyproject.toml src/praisonai-bot/uv.lock src/praisonai-bot/praisonai_bot/_version.py
+          git diff --cached --quiet && { echo "No bot files to commit"; exit 0; }
+          git commit -m "Bump praisonai-bot to ${{ steps.versions.outputs.bot_version }}"
+          git pull --rebase origin main
+          git push origin main
+
       - name: Publish praisonai-train
         if: >-
           inputs.dry_run != true &&
@@ -861,9 +747,7 @@ jobs:
           rm -rf dist
           uv lock
           uv build
-          # --check-url makes re-uploads idempotent: files already on PyPI are
-          # skipped instead of failing the publish (partial-upload recovery).
-          uv publish --check-url https://pypi.org/simple/
+          uv publish
 
       - name: Wait for praisonai-train on PyPI
         if: >-
@@ -892,6 +776,19 @@ jobs:
             sleep "$INTERVAL"
           done
 
+      - name: Commit praisonai-train version bump
+        if: >-
+          inputs.dry_run != true &&
+          inputs.skip_train != true &&
+          steps.pypi_exists.outputs.skip_train != 'true'
+        run: |
+          set -euo pipefail
+          git add src/praisonai-train/pyproject.toml src/praisonai-train/uv.lock src/praisonai-train/praisonai_train/_version.py
+          git diff --cached --quiet && { echo "No train files to commit"; exit 0; }
+          git commit -m "Bump praisonai-train to ${{ steps.versions.outputs.train_version }}"
+          git pull --rebase origin main
+          git push origin main
+
       - name: Publish praisonai-browser
         if: >-
           inputs.dry_run != true &&
@@ -920,9 +817,7 @@ jobs:
           rm -rf dist
           uv lock
           uv build
-          # --check-url makes re-uploads idempotent: files already on PyPI are
-          # skipped instead of failing the publish (partial-upload recovery).
-          uv publish --check-url https://pypi.org/simple/
+          uv publish
 
       - name: Wait for praisonai-browser on PyPI
         if: >-
@@ -951,6 +846,19 @@ jobs:
             sleep "$INTERVAL"
           done
 
+      - name: Commit praisonai-browser version bump
+        if: >-
+          inputs.dry_run != true &&
+          inputs.skip_browser != true &&
+          steps.pypi_exists.outputs.skip_browser != 'true'
+        run: |
+          set -euo pipefail
+          git add src/praisonai-browser/pyproject.toml src/praisonai-browser/uv.lock src/praisonai-browser/praisonai_browser/_version.py
+          git diff --cached --quiet && { echo "No browser files to commit"; exit 0; }
+          git commit -m "Bump praisonai-browser to ${{ steps.versions.outputs.browser_version }}"
+          git pull --rebase origin main
+          git push origin main
+
       - name: Publish praisonai-mcp
         if: >-
           inputs.dry_run != true &&
@@ -979,9 +887,7 @@ jobs:
           rm -rf dist
           uv lock
           uv build
-          # --check-url makes re-uploads idempotent: files already on PyPI are
-          # skipped instead of failing the publish (partial-upload recovery).
-          uv publish --check-url https://pypi.org/simple/
+          uv publish
 
       - name: Wait for praisonai-mcp on PyPI
         if: >-
@@ -1010,6 +916,19 @@ jobs:
             sleep "$INTERVAL"
           done
 
+      - name: Commit praisonai-mcp version bump
+        if: >-
+          inputs.dry_run != true &&
+          inputs.skip_mcp != true &&
+          steps.pypi_exists.outputs.skip_mcp != 'true'
+        run: |
+          set -euo pipefail
+          git add src/praisonai-mcp/pyproject.toml src/praisonai-mcp/uv.lock src/praisonai-mcp/praisonai_mcp/_version.py
+          git diff --cached --quiet && { echo "No mcp files to commit"; exit 0; }
+          git commit -m "Bump praisonai-mcp to ${{ steps.versions.outputs.mcp_version }}"
+          git pull --rebase origin main
+          git push origin main
+
       - name: Publish praisonai-sandbox
         if: >-
           inputs.dry_run != true &&
@@ -1038,9 +957,7 @@ jobs:
           rm -rf dist
           uv lock
           uv build
-          # --check-url makes re-uploads idempotent: files already on PyPI are
-          # skipped instead of failing the publish (partial-upload recovery).
-          uv publish --check-url https://pypi.org/simple/
+          uv publish
 
       - name: Wait for praisonai-sandbox on PyPI
         if: >-
@@ -1069,101 +986,20 @@ jobs:
             sleep "$INTERVAL"
           done
 
-      - name: Publish praisonai-deploy
+      - name: Commit praisonai-sandbox version bump
         if: >-
           inputs.dry_run != true &&
-          inputs.skip_deploy != true &&
-          steps.pypi_exists.outputs.skip_deploy != 'true'
-        working-directory: src/praisonai-deploy
-        env:
-          NEW_VERSION: ${{ steps.versions.outputs.deploy_version }}
-          CURRENT: ${{ steps.versions.outputs.current_deploy }}
+          inputs.skip_sandbox != true &&
+          steps.pypi_exists.outputs.skip_sandbox != 'true'
         run: |
           set -euo pipefail
-          python <<'PY'
-          import os
-          import re
-          from pathlib import Path
-          new = os.environ["NEW_VERSION"]
-          current = os.environ["CURRENT"]
-          pyproject = Path("pyproject.toml")
-          content = pyproject.read_text()
-          pyproject.write_text(content.replace(f'version = "{current}"', f'version = "{new}"', 1))
-          version_py = Path("praisonai_deploy/_version.py")
-          version_content = version_py.read_text()
-          version_py.write_text(re.sub(r'__version__ = "[^"]+"', f'__version__ = "{new}"', version_content, count=1))
-          PY
-
-          rm -rf dist
-          uv lock
-          uv build
-          # --check-url makes re-uploads idempotent: files already on PyPI are
-          # skipped instead of failing the publish (partial-upload recovery).
-          uv publish --check-url https://pypi.org/simple/
-
-      - name: Wait for praisonai-deploy on PyPI
-        if: >-
-          inputs.dry_run != true &&
-          inputs.skip_deploy != true &&
-          steps.pypi_exists.outputs.skip_deploy != 'true'
-        run: |
-          set -euo pipefail
-          PACKAGE="praisonai-deploy"
-          VERSION="${{ steps.versions.outputs.deploy_version }}"
-          MAX_WAIT=600
-          INTERVAL=30
-          START=$(date +%s)
-
-          while true; do
-            if curl -fsSL "https://pypi.org/pypi/${PACKAGE}/${VERSION}/json" >/dev/null; then
-              echo "✅ ${PACKAGE}==${VERSION} is available on PyPI"
-              exit 0
-            fi
-            ELAPSED=$(( $(date +%s) - START ))
-            if [ "$ELAPSED" -ge "$MAX_WAIT" ]; then
-              echo "❌ Timeout waiting for ${PACKAGE}==${VERSION} on PyPI"
-              exit 1
-            fi
-            echo "⏳ Waiting for ${PACKAGE}==${VERSION} ($(( MAX_WAIT - ELAPSED ))s remaining...)"
-            sleep "$INTERVAL"
-          done
-
-      # All per-package version bumps are still uncommitted at this point: the
-      # wrapper release below stages every one of them (bump_and_release.py's
-      # release_files list) into a SINGLE "Release v…" commit.
-
-      # App tokens expire after 1h and this job can exceed that (9 packages ×
-      # up to a 600s PyPI wait). Re-mint so the final commit/tag/push/release
-      # never runs on an expired token.
-      - name: Refresh GitHub App token
-        id: app-token-final
-        if: ${{ !cancelled() && inputs.dry_run != true }}
-        # A failed re-mint must not fail the release: the original token may
-        # still be valid, and the next step only swaps tokens on success.
-        continue-on-error: true
-        uses: actions/create-github-app-token@v1
-        with:
-          app-id: ${{ secrets.CLAUDE_APP_ID }}
-          private-key: ${{ secrets.CLAUDE_APP_PRIVATE_KEY }}
-          owner: ${{ github.repository_owner }}
-          repositories: ${{ github.event.repository.name }}
-
-      # Guarded on the refresh actually succeeding: if the re-mint failed
-      # (API blip), the ORIGINAL token — still wired into the remote URL and
-      # GH_TOKEN — may well be valid, and overwriting it with an empty string
-      # would turn a recoverable situation into a guaranteed auth failure.
-      - name: Use refreshed GitHub App token
-        if: ${{ !cancelled() && inputs.dry_run != true && steps.app-token-final.outcome == 'success' }}
-        env:
-          APP_TOKEN: ${{ steps.app-token-final.outputs.token }}
-          REPO: ${{ github.repository }}
-        run: |
-          set -euo pipefail
-          git remote set-url origin "https://x-access-token:${APP_TOKEN}@github.com/${REPO}.git"
-          echo "GH_TOKEN=${APP_TOKEN}" >> "$GITHUB_ENV"
+          git add src/praisonai-sandbox/pyproject.toml src/praisonai-sandbox/uv.lock src/praisonai-sandbox/praisonai_sandbox/_version.py
+          git diff --cached --quiet && { echo "No sandbox files to commit"; exit 0; }
+          git commit -m "Bump praisonai-sandbox to ${{ steps.versions.outputs.sandbox_version }}"
+          git pull --rebase origin main
+          git push origin main
 
       - name: Bump and release wrapper
-        id: wrapper
         if: >-
           inputs.dry_run != true &&
           inputs.skip_wrapper != true &&
@@ -1178,8 +1014,7 @@ jobs:
             --browser-pin "${{ steps.versions.outputs.browser_version }}" \
             --mcp-pin "${{ steps.versions.outputs.mcp_version }}" \
             --sandbox-pin "${{ steps.versions.outputs.sandbox_version }}" \
-            --deploy-pin "${{ steps.versions.outputs.deploy_version }}" \
-            --wait --max-wait 600 --no-add-all --force
+            --wait --max-wait 600 --no-add-all
 
       - name: Publish praisonai wrapper to PyPI
         if: >-
@@ -1187,7 +1022,7 @@ jobs:
           inputs.skip_wrapper != true &&
           steps.pypi_exists.outputs.skip_wrapper != 'true'
         working-directory: src/praisonai
-        run: uv publish --check-url https://pypi.org/simple/
+        run: uv publish
 
       - name: Wait for praisonai on PyPI
         if: >-
@@ -1216,139 +1051,47 @@ jobs:
             sleep "$INTERVAL"
           done
 
-      # Actually probes PyPI — previously this step only echoed checkmarks
-      # from the input flags, so it "verified" publishes that never happened.
       - name: Verify PyPI versions
         if: inputs.dry_run != true
         run: |
           set -euo pipefail
-          verify() { # $1=pypi-name $2=version $3=effective-skip
-            if [ "$3" = "true" ]; then
-              echo "⏭️  $1 skipped"
-              return 0
-            fi
-            if curl -fsSL --max-time 30 "https://pypi.org/pypi/$1/$2/json" >/dev/null; then
-              echo "✅ $1==$2"
-            else
-              echo "❌ $1==$2 NOT found on PyPI"
-              exit 1
-            fi
-          }
-          verify praisonaiagents  "${{ steps.versions.outputs.agents_version }}"  "${{ steps.flags.outputs.skip_agents }}"
-          verify praisonai-code   "${{ steps.versions.outputs.code_version }}"    "${{ steps.flags.outputs.skip_code }}"
-          verify praisonai-bot    "${{ steps.versions.outputs.bot_version }}"     "${{ steps.flags.outputs.skip_bot }}"
-          verify praisonai-train  "${{ steps.versions.outputs.train_version }}"   "${{ steps.flags.outputs.skip_train }}"
-          verify praisonai-browser "${{ steps.versions.outputs.browser_version }}" "${{ steps.flags.outputs.skip_browser }}"
-          verify praisonai-mcp    "${{ steps.versions.outputs.mcp_version }}"     "${{ steps.flags.outputs.skip_mcp }}"
-          verify praisonai-sandbox "${{ steps.versions.outputs.sandbox_version }}" "${{ steps.flags.outputs.skip_sandbox }}"
-          verify praisonai-deploy "${{ steps.versions.outputs.deploy_version }}"  "${{ steps.flags.outputs.skip_deploy }}"
-          verify praisonai        "${{ steps.versions.outputs.wrapper_version }}" "${{ steps.flags.outputs.skip_wrapper }}"
+          AGENTS="${{ steps.versions.outputs.agents_version }}"
+          CODE="${{ steps.versions.outputs.code_version }}"
+          BOT="${{ steps.versions.outputs.bot_version }}"
+          TRAIN="${{ steps.versions.outputs.train_version }}"
+          BROWSER="${{ steps.versions.outputs.browser_version }}"
+          MCP="${{ steps.versions.outputs.mcp_version }}"
+          SANDBOX="${{ steps.versions.outputs.sandbox_version }}"
+          WRAPPER="${{ steps.versions.outputs.wrapper_version }}"
 
-      # Safety net. On a clean run the wrapper's "Release v…" commit already
-      # carries every bump and this is a no-op. It only fires when the single
-      # commit could not happen: a package publish failed midway (those versions
-      # are already live on PyPI, so the bumps must not be lost), skip_wrapper
-      # was set, or the wrapper itself failed.
-      - name: Persist any uncommitted version bumps
-        if: ${{ !cancelled() && inputs.dry_run != true }}
-        run: |
-          set -euo pipefail
-          # If the wrapper release did not complete, drop any uncommitted
-          # wrapper-side rewrites (version.py, Dockerfiles, pins): committing
-          # them would put a wrapper version on main that never reached PyPI,
-          # and the next auto-bump would skip past it forever. Committed
-          # changes are untouched (checkout only reverts the working tree),
-          # and if the wrapper was skipped these files were never modified.
-          if [ "${{ steps.wrapper.outcome }}" != "success" ]; then
-            git checkout -- \
-              src/praisonai/praisonai/version.py \
-              src/praisonai/pyproject.toml \
-              src/praisonai/uv.lock \
-              src/praisonai/README.md \
-              src/praisonai/praisonai.rb \
-              src/praisonai-deploy/praisonai_deploy/docker.py \
-              docker/ 2>/dev/null || true
+          if [ "${{ inputs.skip_agents }}" != "true" ]; then
+            echo "✅ praisonaiagents==${AGENTS}"
           fi
-          # -u = tracked modifications only; uv build output under dist/ is
-          # untracked and stays out of the commit.
-          git add -u
-          git diff --cached --quiet && { echo "Nothing left to commit"; exit 0; }
-          # Name the packages actually staged, so a single-package release
-          # (every other skip_* set) reads "bump praisonai-mcp" rather than a
-          # generic message. Falls back when nothing under src/ is staged.
-          PKGS="$(git diff --cached --name-only \
-            | sed -n 's#^src/\([^/]*\)/.*#\1#p' | sort -u | tr '\n' ' ' | sed 's/ *$//')"
-          if [ -n "$PKGS" ]; then
-            MSG="chore(release): bump ${PKGS} [skip ci]"
-          else
-            MSG="chore(release): persist version bumps [skip ci]"
-          fi
-          echo "Commit message: ${MSG}"
-          git commit -m "$MSG"
-          # This step fires exactly when the release went sideways — i.e. when
-          # main is most likely to have moved — so the rebase+push retries.
-          # Losing this commit deadlocks future auto-releases: the packages
-          # are on PyPI at N+1 while the repo says N, so every later run
-          # detects "already published" and skips both publish and bump.
-          for attempt in 1 2 3; do
-            git fetch origin main
-            if ! git rebase origin/main; then
-              git rebase --abort || true
-              # During rebase, "theirs" is the commit being replayed — the
-              # version bumps — so they win any conflict.
-              if ! git rebase -X theirs origin/main; then
-                git rebase --abort || true
-                echo "Rebase attempt ${attempt}/3 failed"
-                sleep 5
-                continue
-              fi
-            fi
-            if git push origin main; then
-              echo "Pushed version bumps (attempt ${attempt}/3)"
-              exit 0
-            fi
-            echo "Push attempt ${attempt}/3 rejected; retrying..."
-            sleep 5
-          done
-          echo "❌ Could not push version bumps after 3 attempts."
-          echo "   Repo is now BEHIND PyPI; commit the version files on main manually"
-          echo "   or future auto-releases will no-op ('already published')."
-          exit 1
 
-      # Dedicated releases (skip_wrapper) create no "Release v…" tag — the
-      # wrapper drives that — so tag each published package individually for
-      # provenance. Full releases keep their single v… tag unchanged.
-      - name: Tag dedicated package releases
-        if: >-
-          ${{ !cancelled() && inputs.dry_run != true &&
-              steps.flags.outputs.skip_wrapper == 'true' &&
-              steps.versions.outcome == 'success' }}
-        run: |
-          set -euo pipefail
-          tag_pkg() { # $1=effective-skip $2=pypi-name $3=version
-            if [ "$1" = "true" ]; then
-              return 0
-            fi
-            local tag="$2-v$3"
-            # Only tag what is confirmed on PyPI — a package whose publish
-            # failed must not get a tag claiming it shipped.
-            if ! curl -fsSL --max-time 30 "https://pypi.org/pypi/$2/$3/json" >/dev/null; then
-              echo "⏭️  $2==$3 not on PyPI; not tagging"
-              return 0
-            fi
-            if git rev-parse -q --verify "refs/tags/${tag}" >/dev/null; then
-              echo "tag ${tag} already exists"
-              return 0
-            fi
-            git tag "${tag}"
-            git push origin "refs/tags/${tag}"
-            echo "🏷️  ${tag}"
-          }
-          tag_pkg "${{ steps.flags.outputs.skip_agents }}"  praisonaiagents  "${{ steps.versions.outputs.agents_version }}"
-          tag_pkg "${{ steps.flags.outputs.skip_code }}"    praisonai-code   "${{ steps.versions.outputs.code_version }}"
-          tag_pkg "${{ steps.flags.outputs.skip_bot }}"     praisonai-bot    "${{ steps.versions.outputs.bot_version }}"
-          tag_pkg "${{ steps.flags.outputs.skip_train }}"   praisonai-train  "${{ steps.versions.outputs.train_version }}"
-          tag_pkg "${{ steps.flags.outputs.skip_browser }}" praisonai-browser "${{ steps.versions.outputs.browser_version }}"
-          tag_pkg "${{ steps.flags.outputs.skip_mcp }}"     praisonai-mcp    "${{ steps.versions.outputs.mcp_version }}"
-          tag_pkg "${{ steps.flags.outputs.skip_sandbox }}" praisonai-sandbox "${{ steps.versions.outputs.sandbox_version }}"
-          tag_pkg "${{ steps.flags.outputs.skip_deploy }}"  praisonai-deploy "${{ steps.versions.outputs.deploy_version }}"
+          if [ "${{ inputs.skip_code }}" != "true" ]; then
+            echo "✅ praisonai-code==${CODE}"
+          fi
+
+          if [ "${{ inputs.skip_bot }}" != "true" ]; then
+            echo "✅ praisonai-bot==${BOT}"
+          fi
+
+          if [ "${{ inputs.skip_train }}" != "true" ]; then
+            echo "✅ praisonai-train==${TRAIN}"
+          fi
+
+          if [ "${{ inputs.skip_browser }}" != "true" ]; then
+            echo "✅ praisonai-browser==${BROWSER}"
+          fi
+
+          if [ "${{ inputs.skip_mcp }}" != "true" ]; then
+            echo "✅ praisonai-mcp==${MCP}"
+          fi
+
+          if [ "${{ inputs.skip_sandbox }}" != "true" ]; then
+            echo "✅ praisonai-sandbox==${SANDBOX}"
+          fi
+
+          if [ "${{ inputs.skip_wrapper }}" != "true" ]; then
+            echo "✅ praisonai==${WRAPPER}"
+          fi

.github/workflows/sync-secrets-to-aiui.yml

@@ -24,7 +24,6 @@ jobs:
           CLAUDE_APP_PRIVATE_KEY: ${{ secrets.CLAUDE_APP_PRIVATE_KEY }}
           CLAUDE_CODE_OAUTH_TOKEN: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
           GH_TOKEN_VALUE: ${{ secrets.GH_TOKEN }}
-          DOCS_GITHUB_TOKEN: ${{ secrets.SECRETS_ADMIN_PAT }}
         run: |
           set -euo pipefail
           if [ -z "${GH_TOKEN:-}" ]; then
@@ -35,7 +34,4 @@ jobs:
           echo -n "$CLAUDE_APP_PRIVATE_KEY" | gh secret set CLAUDE_APP_PRIVATE_KEY --repo "$TARGET"
           echo -n "$CLAUDE_CODE_OAUTH_TOKEN" | gh secret set CLAUDE_CODE_OAUTH_TOKEN --repo "$TARGET"
           echo -n "$GH_TOKEN_VALUE" | gh secret set GH_TOKEN --repo "$TARGET"
-          if [ -n "${DOCS_GITHUB_TOKEN:-}" ]; then
-            echo -n "$DOCS_GITHUB_TOKEN" | gh secret set DOCS_GITHUB_TOKEN --repo "$TARGET"
-          fi
           echo "Synced CLAUDE_APP_ID, CLAUDE_APP_PRIVATE_KEY, CLAUDE_CODE_OAUTH_TOKEN, GH_TOKEN → $TARGET"

.github/workflows/test-core.yml

@@ -5,9 +5,6 @@ on:
     branches: [ main, develop ]
     paths:
       - 'src/**'
-      - 'src/praisonai-deploy/infra/**'
-      - 'src/praisonai-bot/infra/**'
-      - 'scripts/check_helm_charts.sh'
       - 'pyproject.toml'
       - '.github/workflows/test-core.yml'
       - '.github/actions/install-monorepo-packages/**'
@@ -15,9 +12,6 @@ on:
     branches: [ main, develop ]
     paths:
       - 'src/**'
-      - 'src/praisonai-deploy/infra/**'
-      - 'src/praisonai-bot/infra/**'
-      - 'scripts/check_helm_charts.sh'
       - 'pyproject.toml'
       - '.github/workflows/test-core.yml'
       - '.github/actions/install-monorepo-packages/**'
@@ -120,17 +114,11 @@ jobs:
             extra_ignore: ""
             pythonpath: >-
               ${{ github.workspace }}/src/praisonai-agents
-          - shard: deploy
-            workdir: src/praisonai-deploy
-            paths: >-
-              tests/
-            extra_ignore: ""
-            pythonpath: >-
-              ${{ github.workspace }}/src/praisonai-agents
           - shard: subdirs
             paths: >-
               tests/unit/scheduler/
               tests/unit/integrations/
+              tests/unit/deploy/
               tests/unit/mcp/
               tests/unit/knowledge/
               tests/unit/llm/
@@ -195,9 +183,6 @@ jobs:
         if [ "$WORKDIR" = "src/praisonai-sandbox" ]; then
           bash "$GITHUB_WORKSPACE/scripts/check_c13_sandbox_imports.sh"
         fi
-        if [ "$WORKDIR" = "src/praisonai-deploy" ]; then
-          bash "$GITHUB_WORKSPACE/scripts/check_c14_deploy_imports.sh"
-        fi
         if [ "$WORKDIR" = "src/praisonai-mcp" ]; then
           bash "$GITHUB_WORKSPACE/scripts/check_c12_mcp_imports.sh"
         fi
@@ -283,27 +268,9 @@ jobs:
           --ignore=tests/integration/test_tracker_complex_tasks.py \
           --ignore=tests/integration/test_serve_integration.py
 
-  helm-charts:
-    name: helm-charts
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        persist-credentials: false
-    - name: Setup Helm
-      uses: azure/setup-helm@v3
-      with:
-        version: v3.14.4
-    - name: Lint and template Helm charts
-      shell: bash
-      run: |
-        set -euo pipefail
-        bash "$GITHUB_WORKSPACE/scripts/check_helm_charts.sh"
-
   test-core:
     name: test-core
-    needs: [test-core-collect, test-core-unit, test-core-integration, helm-charts]
+    needs: [test-core-collect, test-core-unit, test-core-integration]
     if: always()
     runs-on: ubuntu-latest
     timeout-minutes: 5
@@ -315,9 +282,8 @@ jobs:
         collect='${{ needs.test-core-collect.result }}'
         unit='${{ needs.test-core-unit.result }}'
         integration='${{ needs.test-core-integration.result }}'
-        helm='${{ needs.helm-charts.result }}'
-        echo "collect=$collect unit=$unit integration=$integration helm=$helm"
-        if [ "$collect" != "success" ] || [ "$unit" != "success" ] || [ "$integration" != "success" ] || [ "$helm" != "success" ]; then
+        echo "collect=$collect unit=$unit integration=$integration"
+        if [ "$collect" != "success" ] || [ "$unit" != "success" ] || [ "$integration" != "success" ]; then
           echo "Core Tests failed"
           exit 1
         fi

.github/workflows/test-optimized.yml

@@ -86,7 +86,6 @@ jobs:
           tests/unit/test_c11_browser_backward_compat.py \
           tests/unit/test_c12_mcp_backward_compat.py \
           tests/unit/test_c13_sandbox_backward_compat.py \
-          tests/unit/test_c14_deploy_backward_compat.py \
           -q --tb=line --timeout=30 --maxfail=5
         python -m pytest tests/unit/cli/ \
           ../praisonai-bot/tests/unit/cli/test_onboard_command.py \
@@ -270,26 +269,10 @@ jobs:
         bash "$GITHUB_WORKSPACE/scripts/check_c13_sandbox_imports.sh"
         python -m pytest src/praisonai-sandbox/tests -q -m "not network"
 
-    - name: Standalone praisonai-deploy smoke (C14)
-      run: |
-        set -euo pipefail
-        python -m venv /tmp/praisonai-deploy-standalone
-        /tmp/praisonai-deploy-standalone/bin/pip install -q -e src/praisonai-agents -e src/praisonai-deploy
-        /tmp/praisonai-deploy-standalone/bin/python -c "
-        from praisonai_deploy._version import __version__ as pkg_version
-        import praisonai_deploy
-        assert praisonai_deploy.__version__ == pkg_version
-        assert 'main' not in __import__('sys').modules
-        print('deploy standalone ok', praisonai_deploy.__version__)
-        "
-        /tmp/praisonai-deploy-standalone/bin/praisonai-deploy --help
-        bash "$GITHUB_WORKSPACE/scripts/check_c14_deploy_imports.sh"
-        python -m pytest src/praisonai-deploy/tests -q -m "not network"
-
     - name: Audit hybrid module imports (C8 full stack)
       run: |
         set -euo pipefail
-        pip install -q -e src/praisonai-agents -e src/praisonai-code -e src/praisonai-bot -e src/praisonai-train -e src/praisonai-browser -e src/praisonai-mcp -e src/praisonai-sandbox -e src/praisonai-deploy -e src/praisonai
+        pip install -q -e src/praisonai-agents -e src/praisonai-code -e src/praisonai-bot -e src/praisonai-train -e src/praisonai-browser -e src/praisonai-mcp -e src/praisonai-sandbox -e src/praisonai
         python scripts/audit_hybrid_modules.py
     
     - name: Smoke Test Summary
@@ -799,9 +782,6 @@ jobs:
           tests/unit/test_decorator_simple.py
           tests/unit/test_db_adapter_tracing_init.py
           ../praisonai-bot/tests/unit/test_bot_wiring.py
-          ../praisonai-bot/tests/unit/bots/test_enable_shell.py
-          ../praisonai-bot/tests/unit/gateway/test_preflight.py
-          ../praisonai-bot/tests/unit/gateway/test_gateway_doctor.py
           ../praisonai-bot/tests/unit/test_bot_history.py
           ../praisonai-bot/tests/unit/test_bot_fixes.py
           tests/unit/test_auto_lazy_loading.py

.gitignore

@@ -12,7 +12,6 @@ assets
 .DS_Store
 .pytest_cache
 praisonAI.egg-info
-src/*/build/
 flagged
 test.yaml
 db
@@ -25,8 +24,6 @@ output
 !src/praisonai-agents/praisonaiagents/output/
 !src/praisonai-code/praisonai_code/cli/output/
 !src/praisonai-bot/praisonai_bot/cli/output/
-!src/praisonai-ts/src/db/
-!src/praisonai-ts/src/cli/output/
 
 .files
 threads.db

AGENTS.md

@@ -7,9 +7,9 @@ You are working on the PraisonAI project.
 - Be concise and helpful in responses  
 - Test implementation thoroughly
 - Ensure backward compatibility with existing APIs
-- Follow protocol-driven design across the nine packages: core protocols in `praisonaiagents/`, agentic terminal CLI in `praisonai-code/`, bots/gateway in `praisonai-bot/`, LLM fine-tuning + agent training in `praisonai-train/`, browser automation in `praisonai-browser/`, MCP server host in `praisonai-mcp/`, sandbox backends in `praisonai-sandbox/`, deployment in `praisonai-deploy/`, integrations/serve/dashboard in the `praisonai/` wrapper
+- Follow protocol-driven design across the eight packages: core protocols in `praisonaiagents/`, agentic terminal CLI in `praisonai-code/`, bots/gateway in `praisonai-bot/`, LLM fine-tuning + agent training in `praisonai-train/`, browser automation in `praisonai-browser/`, MCP server host in `praisonai-mcp/`, sandbox backends in `praisonai-sandbox/`, integrations/serve/dashboard in the `praisonai/` wrapper
 - Preserve old `praisonai.*` import paths via shims when moving code between packages (see §2.3 in `src/praisonai-agents/AGENTS.md`; shim helpers in `src/praisonai/praisonai/cli/_shim.py`)
 - Package boundaries and dependency rules: `ARCHITECTURE.md` §2 (Tier 2 packages must never PyPI-depend on the wrapper; cross-tier access goes through lazy `_*_bridge` modules)
-- Boundary manifests: `src/praisonai/tests/PRAISONAI_BOT_MANIFEST.md` (C9), `src/praisonai/tests/PRAISONAI_TRAIN_MANIFEST.md` (C10), `src/praisonai/tests/PRAISONAI_BROWSER_MANIFEST.md` (C11), `src/praisonai/tests/PRAISONAI_MCP_MANIFEST.md` (C12), `src/praisonai/tests/PRAISONAI_SANDBOX_MANIFEST.md` (C13), `src/praisonai/tests/PRAISONAI_DEPLOY_MANIFEST.md` (C14)
+- Boundary manifests: `src/praisonai/tests/PRAISONAI_BOT_MANIFEST.md` (C9), `src/praisonai/tests/PRAISONAI_TRAIN_MANIFEST.md` (C10), `src/praisonai/tests/PRAISONAI_BROWSER_MANIFEST.md` (C11), `src/praisonai/tests/PRAISONAI_MCP_MANIFEST.md` (C12), `src/praisonai/tests/PRAISONAI_SANDBOX_MANIFEST.md` (C13)
 - When reviewing a PR or an issue, evaluate whether the change addresses a framework concern or a user goal, and design its surface (params, naming, defaults) accordingly
 - The aim of this package is to stay **lightweight and powerful**. Do a critical review at each stage — when triaging an issue, when planning a fix, and when reviewing/implementing a PR. Reject scope creep for the sake of adding features: if a capability already exists (e.g. via existing Agent params like `instructions`/`backstory`/`tools`/`hooks`/`memory`), prefer it over a new API surface. A change must genuinely strengthen the SDK (simpler, more robust, more user-friendly) — do not add knobs, params, modules, or exports that have no live consumer or that merely duplicate existing behaviour.

ARCHITECTURE.md

@@ -1,6 +1,6 @@
 # PraisonAI Architecture
 
-> **Last updated:** 2026-07-31 (C14 — nine-package tiered model)
+> **Last updated:** 2026-07-17 (C13 — eight-package tiered model)
 >
 > Strategic architecture document for PraisonAI — a multi-agent AI framework.
 > Covers **Python tiered package model (C7.1 + C9 + C10)**, system design, runtime
@@ -11,7 +11,7 @@
 ## Table of Contents
 
 1. [Executive Summary](#1-executive-summary)
-2. [Python Tiered Package Model (C7.1 + C9 + C10 + C11 + C12 + C13 + C14)](#2-python-tiered-package-model-c71--c9--c10--c11--c12--c13--c14)
+2. [Python Tiered Package Model (C7.1 + C9 + C10 + C11 + C12 + C13)](#2-python-tiered-package-model-c71--c9--c10--c11--c12--c13)
 3. [System Overview](#3-system-overview)
 4. [Layered Architecture](#4-layered-architecture)
 5. [Core Data Contracts](#5-core-data-contracts)
@@ -51,18 +51,17 @@ Orchestration + Observability** core to unlock adoption and trust:
 
 ---
 
-## 2. Python Tiered Package Model (C7.1 + C9 + C10 + C11 + C12 + C13 + C14)
+## 2. Python Tiered Package Model (C7.1 + C9 + C10 + C11 + C12 + C13)
 
-**Release:** v4.6.110+ · `praisonaiagents` · `praisonai-code` · `praisonai-bot` · `praisonai-train` · `praisonai-browser` · `praisonai-mcp` · `praisonai-sandbox` · `praisonai-deploy` · `praisonai`
+**Release:** v4.6.110+ · `praisonaiagents` · `praisonai-code` · `praisonai-bot` · `praisonai-train` · `praisonai-browser` · `praisonai-mcp` · `praisonai-sandbox` · `praisonai`
 
-The Python monorepo publishes nine packages in three tiers with strict dependency
+The Python monorepo publishes eight packages in three tiers with strict dependency
 direction. C7 delivered a standalone agentic hot path; C7.1 formalised
 code/wrapper ownership; C9 extracted bots, gateway, and channel CLI into
 `praisonai-bot`; C10 extracted LLM fine-tuning and agent training into
 `praisonai-train`; C11 extracted browser automation into `praisonai-browser`;
 C12 extracted the heavy MCP host into `praisonai-mcp`.
 C13 extracted sandbox backends into `praisonai-sandbox`.
-C14 extracted deployment (API, Docker, cloud) into `praisonai-deploy`.
 
 ```mermaid
 flowchart TB
@@ -70,14 +69,13 @@ flowchart TB
     Agents["praisonaiagents<br/>Agent, tools, memory, hooks, protocols"]
   end
 
-  subgraph tier2 [Tier 2 — Terminal + Bot + Train + Browser + MCP + Sandbox + Deploy]
+  subgraph tier2 [Tier 2 — Terminal + Bot + Train + Browser + MCP + Sandbox]
     Code["praisonai-code<br/>run, chat, code, Typer, runtime, LLM"]
     Bot["praisonai-bot<br/>bots, gateway, channel CLI, OS daemon"]
     Train["praisonai-train<br/>LLM fine-tuning, agent training"]
     Browser["praisonai-browser<br/>extension bridge, CDP, Playwright"]
     MCP["praisonai-mcp<br/>MCP server host, auth, capability adapters"]
     Sandbox["praisonai-sandbox<br/>Docker, E2B, Modal, Sandlock backends"]
-    Deploy["praisonai-deploy<br/>API, Docker, AWS/Azure/GCP deploy"]
   end
 
   subgraph tier3 [Tier 3 — Wrapper]
@@ -90,53 +88,36 @@ flowchart TB
   Agents --> Browser
   Agents --> MCP
   Agents --> Sandbox
-  Agents --> Deploy
   Agents --> Wrapper
   Code -.->|"lazy _bot_bridge"| Bot
   Code -.->|"lazy _train_bridge"| Train
   Code -.->|"lazy _browser_bridge"| Browser
   Code -.->|"lazy _mcp_bridge"| MCP
   Code -.->|"lazy _sandbox_bridge"| Sandbox
-  Code -.->|"lazy _deploy_bridge"| Deploy
   Code -.->|"lazy _wrapper_bridge"| Wrapper
   Bot -.->|"lazy _code_bridge / _wrapper_bridge"| Code
   Bot -.->|"lazy _wrapper_bridge"| Wrapper
   Train -.->|"lazy _code_bridge / _wrapper_bridge"| Code
 ```
 
-**PyPI publish order:** `praisonaiagents` → `praisonai-code` + `praisonai-bot` + `praisonai-train` + `praisonai-browser` + `praisonai-mcp` + `praisonai-sandbox` + `praisonai-deploy` → `praisonai`
+**PyPI publish order:** `praisonaiagents` → `praisonai-code` + `praisonai-bot` + `praisonai-train` + `praisonai-browser` + `praisonai-mcp` + `praisonai-sandbox` → `praisonai`
 
 **Backward compatibility:** `praisonai.bots`, `praisonai.gateway`, `praisonai.train`,
-`praisonai.browser`, `praisonai.mcp_server`, `praisonai.sandbox`, `praisonai.deploy`, and related CLI paths remain as
+`praisonai.browser`, `praisonai.mcp_server`, `praisonai.sandbox`, and related CLI paths remain as
 `alias_package` shims to `praisonai_bot.*` / `praisonai_train.*` /
-`praisonai_browser.*` / `praisonai_mcp.*` / `praisonai_sandbox.*` / `praisonai_deploy.*`.
+`praisonai_browser.*` / `praisonai_mcp.*` / `praisonai_sandbox.*`.
 
 | Tier | Package | Owns | Must not depend on |
 |------|---------|------|-------------------|
-| 1 | `src/praisonai-agents/` | Agent, tools, memory, hooks, `frameworks/` protocols, sandbox protocols | `praisonai`, `praisonai-code`, `praisonai-bot`, `praisonai-train`, `praisonai-browser`, `praisonai-mcp`, `praisonai-sandbox`, `praisonai-deploy` |
+| 1 | `src/praisonai-agents/` | Agent, tools, memory, hooks, `frameworks/` protocols, sandbox protocols | `praisonai`, `praisonai-code`, `praisonai-bot`, `praisonai-train`, `praisonai-browser`, `praisonai-mcp`, `praisonai-sandbox` |
 | 2a | `src/praisonai-code/` | `run`/`chat`/`code`, Typer, runtime, LLM, tool resolution | **`praisonai` as a PyPI dependency** (optional lazy imports via `_wrapper_bridge` only) |
 | 2b | `src/praisonai-bot/` | Bots, gateway, channel CLI, OS daemon, gateway scheduler tick | **`praisonai` as a PyPI dependency** (optional lazy `_wrapper_bridge` for jobs/UI) |
 | 2c | `src/praisonai-train/` | LLM fine-tuning (Unsloth), agent training, `train` CLI, conda env setup | **`praisonai` as a PyPI dependency** (lazy `_code_bridge` for legacy dispatch) |
 | 2d | `src/praisonai-browser/` | Extension bridge, CDP/hybrid automation, `browser` CLI | **`praisonai` as a PyPI dependency** (none required; depends on `praisonaiagents` only) |
 | 2e | `src/praisonai-mcp/` | MCP server host, auth, transports, `mcp` CLI | **`praisonai` as a PyPI dependency** (lazy `_wrapper_bridge` for full capability registry) |
 | 2f | `src/praisonai-sandbox/` | Sandbox backends (Docker, E2B, Modal, Sandlock, SSH), `SandboxRegistry` | **`praisonai` as a PyPI dependency** (lazy `_code_bridge` for `PluginRegistry`) |
-| 2g | `src/praisonai-deploy/` | Deploy API/Docker/cloud, `deploy` CLI, scheduler integration | **`praisonai` as a PyPI dependency** (lazy `_plugin_registry` via `_code_bridge`) |
 | 3 | `src/praisonai/` | `framework_adapters/`, serve, dashboard, async jobs API | — |
 
-### Repo infra (not PyPI)
-
-Deployment packaging that stays in the git checkout, not in any tier-2 wheel:
-
-| Path | Runtime owner | Orchestration |
-|------|---------------|---------------|
-| `src/praisonai-bot/infra/helm/praisonai-gateway/` | `praisonai-bot` (gateway) | C14 `deploy helm` wrapper |
-| `src/praisonai-deploy/infra/helm/praisonai-agents-api/` | Generated API from C14 | C14 cross-link |
-| `src/praisonai-deploy/infra/compose/agents-stack/` | Docker Compose | `praisonai deploy compose up/down` |
-| `src/praisonai-deploy/infra/starters/` | Starter scaffolds | `praisonai deploy create --template` |
-| `docker/` | Mixed (wrapper/bot dev stacks) | Not C14 — see bot manifest for `docker/bots/` |
-
-Same boundary as C14: Helm/K8s manifests are **repo infra**, not `pip install praisonai-deploy` content.
-
 **Config kernel:** Phase 0 `praisonai/common/` was skipped; shared config lives in
 `praisonai_code/cli/configuration/` and is reached by the bot tier via lazy
 `_code_bridge` (see `src/praisonai/tests/CONFIG_KERNEL.md`).

README.md

@@ -41,6 +41,10 @@ curl -fsSL https://praison.ai/install.sh | bash
   <img src=".github/images/dashboard.png" alt="PraisonAI Dashboard" width="800" />
 </p>
 
+<p align="center">
+  <img src=".github/images/agentflow.gif" alt="PraisonAI AgentFlow" width="800" />
+</p>
+
 ```
  ██████╗ ██████╗  █████╗ ██╗███████╗ ██████╗ ███╗   ██╗     █████╗ ██╗
  ██╔══██╗██╔══██╗██╔══██╗██║██╔════╝██╔═══██╗████╗  ██║    ██╔══██╗██║
@@ -52,6 +56,12 @@ curl -fsSL https://praison.ai/install.sh | bash
  pip install praisonai
 ```
 
+<p align="center">
+  <img src=".github/images/latest_ai_news_and_crawl_each_url_to_find_info.gif" alt="PraisonAI command execution" width="800" />
+</p>
+
+\* `export TAVILY_API_KEY=xxxxx`
+
 <div align="center">
   <a href="https://docs.praison.ai">
     <p align="center">
@@ -96,203 +106,6 @@ agent.start("Analyze the top 3 tech trends of 2026 and format as a markdown tabl
 
 ---
 
-## 🧬 The Five-Layer Agent Stack
-
-Most frameworks hand you one or two layers and leave the rest as homework. PraisonAI covers **all five** — plus the outer layer that decides *where* your agent actually runs.
-
-Each layer wraps the one inside it. When an agent misbehaves, the layer tells you where to look.
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│ ⬡ MANAGED AGENTS — Where does it actually run?                  │
-│ ┌─────────────────────────────────────────────────────────────┐ │
-│ │ 5 · GRAPH — Who runs when, and who checks whom?             │ │
-│ │ ┌─────────────────────────────────────────────────────────┐ │ │
-│ │ │ 4 · LOOP — When do we stop?                             │ │ │
-│ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │
-│ │ │ │ 3 · HARNESS — Can it act, and be checked?           │ │ │ │
-│ │ │ │ ┌─────────────────────────────────────────────────┐ │ │ │ │
-│ │ │ │ │ 2 · CONTEXT — Is the right thing in the window? │ │ │ │ │
-│ │ │ │ │ ┌─────────────────────────────────────────────┐ │ │ │ │ │
-│ │ │ │ │ │ 1 · PROMPT — Did I say it clearly?          │ │ │ │ │ │
-│ │ │ │ │ └─────────────────────────────────────────────┘ │ │ │ │ │
-│ │ │ │ └─────────────────────────────────────────────────┘ │ │ │ │
-│ │ │ └─────────────────────────────────────────────────────┘ │ │ │
-│ │ └─────────────────────────────────────────────────────────┘ │ │
-│ └─────────────────────────────────────────────────────────────┘ │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-| Layer | The question it answers | PraisonAI |
-|:--|:--|:--|
-| **1 · Prompt** | Did I say it clearly? | `instructions=`, `role`/`goal`/`backstory`, `output=`, `templates=` |
-| **2 · Context** | Is the right thing in the window? | `memory=`, `knowledge=`, `context=`, handoff `ContextPolicy` |
-| **3 · Harness** | Can it act, and be checked? | `tools=`, `MCP()`, `guardrails=`, `approval=`, `hooks=`, `sandbox=` |
-| **4 · Loop** | When do we stop? | `execution=ExecutionConfig(...)`, `reflection=`, `autonomy=`, doom-loop detection |
-| **5 · Graph** | Who runs when, and who checks whom? | `AgentFlow`, `route()`, `parallel()`, `loop()`, `repeat()` |
-| **⬡ Managed** | *Where does it actually run?* | `run_on="docker"` — one shared remote sandbox, or a fully hosted loop |
-
-### Layer 1 · Prompt — *Did I say it clearly?*
-
-Role, instructions, examples, output format.
-
-```python
-from praisonaiagents import Agent
-
-agent = Agent(
-    role="Senior Data Analyst",
-    goal="Turn raw numbers into decisions",
-    output="verbose",              # markdown-formatted output
-)
-agent.start("Summarise Q3 revenue trends")
-```
-
-### Layer 2 · Context — *Is the right thing in the window?*
-
-Write, select, compress, isolate — the four context operations, one parameter each.
-
-```python
-from praisonaiagents import Agent
-
-agent = Agent(
-    instructions="You are a support engineer.",
-    memory={"user_id": "u-42"},    # write    — persists across runs (needs a user_id)
-    knowledge=["docs/"],           # select   — retrieves only what's relevant
-    context="summarize",           # compress — auto-compacts before the limit
-)
-```
-
-> **Isolate** is `handoffs=[specialist]` — a sub-agent inherits the last few messages and the intersection of your tools, not your whole transcript. [📖 Handoffs](https://docs.praison.ai/docs/concepts/handoffs)
-
-### Layer 3 · Harness — *Can it act, and be checked?*
-
-*Agent = Model + Harness.* Tool dispatch, plus the guides that steer before acting and the sensors that observe after.
-
-```python
-from praisonaiagents import Agent, MCP, tool
-
-@tool
-def deploy(env: str) -> str:
-    """Deploy the current build to an environment."""
-    return f"Deployed to {env}"
-
-agent = Agent(
-    name="ReleaseEngineer",
-    instructions="You are a release engineer.",
-    tools=[deploy, MCP("npx -y @modelcontextprotocol/server-filesystem /tmp")],
-    approval=True,                 # guide — human gate before risky tools run
-)
-agent.start("Deploy to staging, then list the files you can read")
-```
-
-### Layer 4 · Loop — *When do we stop?*
-
-Hard iteration caps, budget ceilings, no-progress detection and completion checks — every brake is explicit.
-
-```python
-from praisonaiagents import Agent, ExecutionConfig
-
-agent = Agent(
-    instructions="Fix the failing tests.",
-    execution=ExecutionConfig(max_iter=30, max_budget=0.50, on_budget_exceeded="stop"),
-    autonomy=True,                 # required to drive the loop with run_autonomous()
-)
-result = agent.run_autonomous("Refactor the auth module", max_iterations=5)
-
-print(result.completion_reason)
-# goal | no_tool_calls | max_iterations | timeout | doom_loop | needs_help | error
-# (with on_budget_exceeded="stop", hitting the cap raises BudgetExceededError,
-#  surfaced here as completion_reason="error")
-```
-
-> **Doom-loop detection is on by default.** Repeated identical tool calls and A→B→A→B oscillation get caught — while a poller whose output keeps changing does not. [📖 Doom Loop Detection](https://docs.praison.ai/docs/features/doom-loop-detection)
-
-### Layer 5 · Graph — *Who runs when, and who checks whom?*
-
-Topology as a versionable artifact: prompt chaining, routing, parallelisation, orchestrator-worker.
-
-```python
-from praisonaiagents import AgentFlow
-from praisonaiagents.workflows import route, parallel, repeat
-
-flow = AgentFlow(steps=[
-    classifier,
-    route({"bug": [bug_agent], "feature": [feature_agent], "default": [triage]}),
-    parallel([reviewer, tester]),                      # fan out, join automatically
-    repeat(editor, until=lambda ctx: "approved" in ctx.previous_result.lower(),
-           max_iterations=3),                          # evaluator–optimizer
-])
-flow.run("Ticket #123: login fails on Safari")
-```
-
-> The same graph is expressible in YAML with no Python at all. [📖 AgentFlow](https://docs.praison.ai/docs/concepts/agentflow)
-
-### ⬡ Outside the stack: Managed Agents — *Where does it actually run?*
-
-The harness is commoditising; **where** the agent executes is the next multiplier. Rather than burning your laptop's CPU, hand an agent a short-lived cloud sandbox — repo, tools and tests run there.
-
-```bash
-pip install praisonai
-```
-
-The simplest way in is `run_on=` — one whole team or workflow shares **one** sandbox, so a file written by step 1 is there for step 2:
-
-```python
-from praisonaiagents import Agent, AgentFlow
-
-writer = Agent(name="Writer", instructions="You write files.")
-reader = Agent(name="Reader", instructions="You read files.")
-
-flow = AgentFlow(run_on="docker", steps=[writer, reader])   # or e2b | modal | daytona | flyio
-flow.run("Write 'hello' to /workspace/note.txt, then read it back")
-```
-
-Same thing with no Python at all:
-
-```yaml
-name: remote-demo
-run_on: docker            # every step shares one sandbox
-agents:
-  writer: {role: Writer, goal: Write files}
-  reader: {role: Reader, goal: Read files}
-steps:
-  - agent: writer
-    action: "Write 'hello' to /workspace/note.txt"
-  - agent: reader
-    action: "Read /workspace/note.txt"
-```
-
-For a single agent, pick the axis you need — remote **tools** or a remote **loop**:
-
-```python
-from praisonai import Agent, LocalAgent, LocalAgentConfig, HostedAgent
-
-# A. Tools run in a remote sandbox; the agent loop stays local
-agent = Agent(name="builder", backend=LocalAgent(
-    compute="e2b",                     # or modal | daytona | flyio | docker | tenki
-    config=LocalAgentConfig(model="gpt-4o-mini", name="RemoteTools"),
-))
-
-# B. The entire agent loop runs in the cloud (needs ANTHROPIC_API_KEY)
-agent = Agent(name="teacher", backend=HostedAgent(provider="anthropic"))
-agent.start("Write a Python script that prints the first 10 primes, then run it")
-```
-
-See what is running and reclaim strays:
-
-```bash
-praisonai managed ps          # list running sandboxes
-praisonai managed stop --all  # reclaim them
-```
-
-Sandboxes shut themselves down when idle (`auto_shutdown`, `idle_timeout_s`), and a post-setup snapshot is reused so the next run skips the image pull and dependency install. Commit a `.praisonai/environment.yaml` and the environment travels with the repo.
-
-> 📖 [20 runnable examples](examples/python/managed-agents/) · manage sessions with `praisonai managed sessions list <agent-id>` or `praisonai managed sessions resume <session-id> "<prompt>"`
-
-<sub>Stack framing adapted from [The Five-Layer Agent Stack](https://mer.vin/2026/07/five-layer-agent-stack-match-bug-to-right-layer/) and [Agent Harnesses vs Orbs](https://mer.vin/2026/08/agent-harnesses-vs-orbs-why-remote-sandboxes-beat-local-agent-loops/).</sub>
-
----
-
 ## 🌌 The PraisonAI Ecosystem
 
 Start simple with the core SDK, or expand to full visual builders and dashboards when you're ready.
@@ -387,9 +200,9 @@ Powered by 100+ LLMs (OpenAI, Anthropic, Gemini & local models).
 | 🧠 | **Planning Mode** — plan → execute → reason | `planning=True` |
 | 🔍 | **Deep Research** — multi-step autonomous research | [Docs](https://docs.praison.ai/docs/agents/deep-research) |
 | 🤖 | **External Agents** — orchestrate Claude Code, Gemini CLI, Codex | [Docs](https://docs.praison.ai/docs/code/external-agents) |
-| 🔄 | **Agent Handoffs** — seamless conversation passing | `handoffs=[other_agent]` |
+| 🔄 | **Agent Handoffs** — seamless conversation passing | `handoff=True` |
 | 🛡️ | **Guardrails** — input/output validation | [Docs](https://docs.praison.ai/docs/concepts/guardrails) |
-|  | **Web Search + Fetch** — native browsing | `web=True` |
+|  | **Web Search + Fetch** — native browsing | `web_search=True` |
 | 🪞 | **Self Reflection** — agent reviews its own output | [Docs](https://docs.praison.ai/docs/concepts/reflection) |
 | 🔀 | **Workflow Patterns** — route, parallel, loop, repeat | [Docs](https://docs.praison.ai/docs/concepts/agentflow) |
 | 🧠 | **Memory (zero deps)** — works out of the box | `memory=True` |
@@ -399,9 +212,9 @@ Powered by 100+ LLMs (OpenAI, Anthropic, Gemini & local models).
 
 | | Feature | How |
 |--|---------|-----|
-| 💡 | **Prompt Caching** — reduce latency + cost | `caching=True` |
+| 💡 | **Prompt Caching** — reduce latency + cost | `prompt_caching=True` |
 | 💾 | **Sessions + Auto-Save** — persistent state across restarts | `auto_save="my-project"` |
-| 💭 | **Thinking Budgets** — control reasoning depth | `agent.thinking_budget = 1024` |
+| 💭 | **Thinking Budgets** — control reasoning depth | `thinking_budget=1024` |
 | 📚 | **RAG + Quality-Based RAG** — auto quality scoring retrieval | [Docs](https://docs.praison.ai/docs/concepts/rag) |
 | 📊 | **Model Router** — auto-routes to cheapest capable model | [Docs](https://docs.praison.ai/docs/features/model-router) |
 | 🧊 | **Shadow Git Checkpoints** — auto-rollback on failure | [Docs](https://docs.praison.ai/docs/features/checkpoints) |
@@ -528,10 +341,8 @@ from praisonaiagents import Agent, db
 
 agent = Agent(
     name="Assistant",
-    memory={
-        "db": db(database_url="postgresql://localhost/mydb"),
-        "session_id": "my-session",
-    },
+    db=db(database_url="postgresql://localhost/mydb"),
+    session_id="my-session"
 )
 agent.chat("Hello!")  # Auto-persists messages, runs, traces
 ```
@@ -977,16 +788,6 @@ PraisonAI is built for speed, with agent instantiation in around 14μs. This red
 
 ---
 
-<p align="center">
-  <img src=".github/images/agentflow.gif" alt="PraisonAI AgentFlow" width="800" />
-</p>
-
-<p align="center">
-  <img src=".github/images/latest_ai_news_and_crawl_each_url_to_find_info.gif" alt="PraisonAI command execution" width="800" />
-</p>
-
-\* `export TAVILY_API_KEY=xxxxx`
-
 ## 🔍 Langfuse Tracing
 
 ```bash
@@ -1090,10 +891,8 @@ from praisonaiagents import Agent, db
 
 agent = Agent(
     name="Assistant",
-    memory={
-        "db": db(database_url="postgresql://localhost/mydb"),
-        "session_id": "my-session",
-    },
+    db=db(database_url="postgresql://localhost/mydb"),
+    session_id="my-session"
 )
 ```
 
@@ -1109,8 +908,8 @@ from praisonaiagents import Agent
 
 agent = Agent(
     name="Assistant",
-    # Enables file-based memory (no extra deps!)
-    memory={"user_id": "user123"},
+    memory=True,  # Enables file-based memory (no extra deps!)
+    user_id="user123"
 )
 ```
 

api.md

@@ -7,7 +7,7 @@ Regenerate with: `praisonai docs api-md --write`
 
 Types:
 ```python
-from praisonaiagents import ContextPolicy, GuardrailResult, HandoffConfig, HandoffCycleError, HandoffDepthError, HandoffError, HandoffInputData, HandoffResult, HandoffTimeoutError, ReflectionOutput, StepResult, ToolResult, ToolValidationError, WorkflowContext
+from praisonaiagents import ContextPolicy, GuardrailResult, HandoffConfig, HandoffCycleError, HandoffDepthError, HandoffError, HandoffInputData, HandoffResult, HandoffTimeoutError, ReflectionOutput, StepResult, TaskOutput, ToolResult, ToolValidationError, WorkflowContext
 ```
 
 Methods:
@@ -16,6 +16,8 @@ Methods:
 * <code title="class HandoffConfig">HandoffConfig.<a href="./src/praisonai-agents/praisonaiagents/agent/handoff.py">from_dict</a>(data: Dict[str, Any]) -> 'HandoffConfig'</code>
 * <code title="class HandoffConfig">HandoffConfig.<a href="./src/praisonai-agents/praisonaiagents/agent/handoff.py">to_dict</a>() -> Dict[str, Any]</code>
 * <code title="class HandoffResult">HandoffResult.<a href="./src/praisonai-agents/praisonaiagents/agent/handoff.py">from_outcome</a>(outcome: AgentRunOutcome, target_agent: Optional[str] = None, source_agent: Optional[str] = None, handoff_depth: int = 0) -> 'HandoffResult'</code>
+* <code title="class TaskOutput">TaskOutput.<a href="./src/praisonai-agents/praisonaiagents/main.py">json</a>() -> Optional[str]</code>
+* <code title="class TaskOutput">TaskOutput.<a href="./src/praisonai-agents/praisonaiagents/main.py">to_dict</a>() -> dict</code>
 * <code title="class ToolResult">ToolResult.<a href="./src/praisonai-agents/praisonaiagents/tools/base.py">is_multimodal</a>() -> bool</code>
 * <code title="class ToolResult">ToolResult.<a href="./src/praisonai-agents/praisonaiagents/tools/base.py">to_dict</a>() -> Dict[str, Any]</code>
 
@@ -23,7 +25,7 @@ Methods:
 
 Types:
 ```python
-from praisonaiagents import Agent, AutoAgents, AutoRagAgent, ContextAgent, DeepResearchAgent, ImageAgent, PlanningAgent, PraisonAIAgents, PromptExpanderAgent, QueryRewriterAgent, create_context_agent
+from praisonaiagents import Agent, AutoAgents, AutoRagAgent, ContextAgent, DeepResearchAgent, ImageAgent, PlanningAgent, PromptExpanderAgent, QueryRewriterAgent, create_context_agent
 ```
 
 Methods:
@@ -34,9 +36,13 @@ Methods:
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">analyze_prompt</a>(prompt: str) -> set</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">auto_memory</a>() -> Optional[bool]</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">auto_memory</a>(value: Optional[bool]) -> None</code>
+* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">background</a>() -> Optional[bool]</code>
+* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">background</a>(value: Optional[bool]) -> None</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">chat_history</a>()</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">chat_history</a>(value)</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">chat_with_context</a>(message: str, context: 'ContextPack', **kwargs) -> str</code>
+* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">checkpoints</a>() -> Optional[bool]</code>
+* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">checkpoints</a>(value: Optional[bool]) -> None</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">clone_for_channel</a>() -> 'Agent'</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">close</a>() -> None</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">console</a>() -> Optional[Any]</code>
@@ -77,7 +83,6 @@ Methods:
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">run_autonomous_async</a>(prompt: str, max_iterations: Optional[int] = None, timeout_seconds: Optional[float] = None, completion_promise: Optional[str] = None, clear_context: bool = False)</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">run_until</a>(prompt: str, criteria: str = '', threshold: float = 8.0, max_iterations: int = 5, mode: str = 'optimize', on_iteration: Optional[Callable[[Any], None]] = None, verbose: bool = False, goal: Optional[str] = None, goal_criteria: Optional[Any] = None, judge_model: Optional[str] = None) -> 'EvaluationLoopResult'</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">run_until_async</a>(prompt: str, criteria: str, threshold: float = 8.0, max_iterations: int = 5, mode: str = 'optimize', on_iteration: Optional[Callable[[Any], None]] = None, verbose: bool = False) -> 'EvaluationLoopResult'</code>
-* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">set_snapshot_root</a>(project_path: str) -> bool</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">skill_manager</a>() -> Optional[Any]</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">store_memory</a>(content: str, memory_type: str = 'short_term', action: str = 'add', **kwargs: Any) -> None</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">stream_emitter</a>() -> Optional[Any]</code>
@@ -86,7 +91,6 @@ Methods:
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">thinking_budget</a>(value: Optional[int]) -> None</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">total_cost</a>() -> float</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">undo</a>() -> bool</code>
-* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">where_does_it_run</a>() -> str</code>
 * <code title="class AutoAgents">AutoAgents.<a href="./src/praisonai-agents/praisonaiagents/agents/autoagents.py">astart</a>()</code>
 * <code title="class AutoAgents">AutoAgents.<a href="./src/praisonai-agents/praisonaiagents/agents/autoagents.py">start</a>()</code>
 * <code title="class AutoRagAgent">AutoRagAgent.<a href="./src/praisonai-agents/praisonaiagents/agents/auto_rag_agent.py">achat</a>(message: str, **kwargs) -> str</code>
@@ -175,15 +179,14 @@ Methods:
 * <code title="class BaseTool">BaseTool.<a href="./src/praisonai-agents/praisonaiagents/tools/base.py">get_schema</a>() -> Dict[str, Any]</code>
 * <code title="class BaseTool">BaseTool.<a href="./src/praisonai-agents/praisonaiagents/tools/base.py">run</a>(**kwargs) -> Any</code>
 * <code title="class BaseTool">BaseTool.<a href="./src/praisonai-agents/praisonaiagents/tools/base.py">safe_run</a>(**kwargs) -> ToolResult</code>
-* <code title="class BaseTool">BaseTool.<a href="./src/praisonai-agents/praisonaiagents/tools/base.py">to_model_output</a>(result: Any) -> Optional[Any]</code>
 * <code title="class BaseTool">BaseTool.<a href="./src/praisonai-agents/praisonaiagents/tools/base.py">validate</a>() -> bool</code>
 * <code title="class BaseTool">BaseTool.<a href="./src/praisonai-agents/praisonaiagents/tools/base.py">validate_class</a>() -> bool</code>
 * <code title="class BaseTool">BaseTool.<a href="./src/praisonai-agents/praisonaiagents/tools/base.py">validate_schema_roundtrip</a>() -> bool</code>
 * <code title="class FunctionTool">FunctionTool.<a href="./src/praisonai-agents/praisonaiagents/tools/decorator.py">__call__</a>(*args, **kwargs) -> Any</code>
 * <code title="class FunctionTool">FunctionTool.<a href="./src/praisonai-agents/praisonaiagents/tools/decorator.py">check_availability</a>() -> tuple[bool, str]</code>
+* <code title="class FunctionTool">FunctionTool.<a href="./src/praisonai-agents/praisonaiagents/tools/decorator.py">get_schema</a>() -> Dict[str, Any]</code>
 * <code title="class FunctionTool">FunctionTool.<a href="./src/praisonai-agents/praisonaiagents/tools/decorator.py">injected_params</a>() -> Dict[str, Any]</code>
 * <code title="class FunctionTool">FunctionTool.<a href="./src/praisonai-agents/praisonaiagents/tools/decorator.py">run</a>(**kwargs) -> Any</code>
-* <code title="class FunctionTool">FunctionTool.<a href="./src/praisonai-agents/praisonaiagents/tools/decorator.py">to_model_output</a>(result: Any) -> Optional[Any]</code>
 * <code title="class ToolRegistry">ToolRegistry.<a href="./src/praisonai-agents/praisonaiagents/tools/registry.py">clear</a>() -> None</code>
 * <code title="class ToolRegistry">ToolRegistry.<a href="./src/praisonai-agents/praisonaiagents/tools/registry.py">discover_plugins</a>() -> int</code>
 * <code title="class ToolRegistry">ToolRegistry.<a href="./src/praisonai-agents/praisonaiagents/tools/registry.py">discover_single_file_plugins</a>() -> int</code>
@@ -249,12 +252,9 @@ Methods:
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">delete_memory</a>(memory_id: str, memory_type: Optional[str] = None) -> bool</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">delete_short_term</a>(memory_id: str) -> bool</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">finalize_task_output</a>(content: str, agent_name: str, quality_score: float, threshold: float = 0.7, metrics: Dict[str, Any] = None, task_id: str = None)</code>
-* <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">forget</a>(**kwargs) -> int</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">get_all_memories</a>() -> List[Dict[str, Any]]</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">get_learn_context</a>() -> str</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">learn</a>()</code>
-* <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">recall</a>(query: str, **kwargs) -> List[Dict[str, Any]]</code>
-* <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">remember</a>(content: str, **kwargs) -> str</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">reset_all</a>()</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">reset_entity_only</a>()</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">reset_long_term</a>()</code>
@@ -262,8 +262,8 @@ Methods:
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">reset_user_memory</a>()</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">search</a>(query: str, user_id: Optional[str] = None, agent_id: Optional[str] = None, run_id: Optional[str] = None, limit: int = 5, rerank: bool = False, **kwargs) -> List[Dict[str, Any]]</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">search_entity</a>(query: str, limit: int = 5) -> List[Dict[str, Any]]</code>
-* <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">search_long_term</a>(query: str, limit: int = 5, relevance_cutoff: float = 0.0, min_quality: float = 0.0, rerank: bool = False, metadata_filter: Optional[Dict[str, Any]] = None, user_id: Optional[str] = None, **kwargs) -> List[Dict[str, Any]]</code>
-* <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">search_short_term</a>(query: str, limit: int = 5, min_quality: float = 0.0, relevance_cutoff: float = 0.0, rerank: bool = False, metadata_filter: Optional[Dict[str, Any]] = None, user_id: Optional[str] = None, **kwargs) -> List[Dict[str, Any]]</code>
+* <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">search_long_term</a>(query: str, limit: int = 5, relevance_cutoff: float = 0.0, min_quality: float = 0.0, rerank: bool = False, **kwargs) -> List[Dict[str, Any]]</code>
+* <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">search_short_term</a>(query: str, limit: int = 5, min_quality: float = 0.0, relevance_cutoff: float = 0.0, rerank: bool = False, **kwargs) -> List[Dict[str, Any]]</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">search_user_memory</a>(user_id: str, query: str, limit: int = 5, rerank: bool = False, **kwargs) -> List[Dict[str, Any]]</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">search_with_quality</a>(query: str, min_quality: float = 0.0, memory_type: Literal['short', 'long'] = 'long', limit: int = 5) -> List[Dict[str, Any]]</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">store_entity</a>(name: str, type_: str, desc: str, relations: str)</code>
@@ -463,7 +463,7 @@ Methods:
 
 Types:
 ```python
-from praisonaiagents import SkillLoader, SkillsConfig
+from praisonaiagents import SkillLoader, SkillManager, SkillMetadata, SkillProperties, SkillsConfig
 ```
 
 Methods:
@@ -475,6 +475,54 @@ Methods:
 * <code title="class SkillLoader">SkillLoader.<a href="./src/praisonai-agents/praisonaiagents/skills/loader.py">load_metadata</a>(skill_path: str) -> Optional[LoadedSkill]</code>
 * <code title="class SkillLoader">SkillLoader.<a href="./src/praisonai-agents/praisonaiagents/skills/loader.py">load_references</a>(skill: LoadedSkill) -> dict</code>
 * <code title="class SkillLoader">SkillLoader.<a href="./src/praisonai-agents/praisonaiagents/skills/loader.py">load_scripts</a>(skill: LoadedSkill) -> dict</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">activate</a>(skill: LoadedSkill) -> bool</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">activate_by_name</a>(name: str) -> bool</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">add_bundle</a>(manifest: 'BundleManifest') -> None</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">add_skill</a>(skill_path: str) -> Optional[LoadedSkill]</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">add_skill_by_name</a>(name: str, skill_dirs: Optional[List[str]] = None, include_defaults: bool = True) -> Optional[LoadedSkill]</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">approve</a>(identifier: str) -> dict</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">archive_skill</a>(name: str) -> dict</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">bundle_names</a>() -> List[str]</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">bundles</a>() -> List['BundleManifest']</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">clear</a>() -> None</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">create</a>(name: str, content: str, category: Optional[str] = None, propose: Optional[bool] = None) -> dict</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">create_skill</a>(name: str, content: str, category: str = None, agent_created: bool = True, propose: Optional[bool] = None, base_dir: Optional[str] = None) -> dict</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">delete</a>(name: str, propose: Optional[bool] = None) -> dict</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">delete_skill</a>(name: str, hard: bool = False, propose: Optional[bool] = None) -> dict</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">discover</a>(skill_dirs: Optional[List[str]] = None, include_defaults: bool = True) -> int</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">discover_bundles</a>(skill_dirs: Optional[List[str]] = None, include_defaults: bool = True) -> int</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">edit</a>(name: str, content: str, propose: Optional[bool] = None) -> dict</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">edit_skill</a>(name: str, content: str, propose: Optional[bool] = None) -> dict</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">get_allowed_tools</a>(name: str) -> List[str]</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">get_available_skills</a>() -> List[SkillMetadata]</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">get_available_skills_by_state</a>(state: SkillState) -> List[LoadedSkill]</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">get_bundle</a>(name: str) -> Optional['BundleManifest']</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">get_bundle_instructions</a>() -> List[str]</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">get_instructions</a>(name: str) -> Optional[str]</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">get_skill</a>(name: str) -> Optional[LoadedSkill]</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">get_skills_diagnostics</a>() -> Dict[str, ValidationResult]</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">get_user_invocable_skills</a>() -> List[LoadedSkill]</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">invoke</a>(name: str, raw_args: str = '', session_id: Optional[str] = None, shell_exec: bool = False) -> Optional[str]</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">list_archived_skills</a>() -> List[str]</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">list_pending</a>() -> List[dict]</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">load_resources</a>(name: str) -> bool</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">patch</a>(name: str, old_string: str, new_string: str, file_path: Optional[str] = None, replace_all: bool = False, propose: Optional[bool] = None) -> dict</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">patch_skill</a>(name: str, old_string: str, new_string: str, file_path: str = None, replace_all: bool = False, propose: Optional[bool] = None) -> dict</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">reject</a>(identifier: str) -> dict</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">remove_file</a>(name: str, file_path: str, propose: Optional[bool] = None) -> dict</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">remove_skill_file</a>(name: str, file_path: str, propose: Optional[bool] = None) -> dict</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">resolve</a>(selectors: List[str]) -> List[str]</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">restore_skill</a>(name: str, skill_dir: Optional[str] = None) -> dict</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">rollback_skill</a>(name: str) -> dict</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">skill_names</a>() -> List[str]</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">skills</a>() -> List[LoadedSkill]</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">to_prompt</a>() -> str</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">validate_skill_capabilities</a>(skill_name: str, force_refresh: bool = False) -> ValidationResult</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">write_file</a>(name: str, file_path: str, file_content: str, propose: Optional[bool] = None) -> dict</code>
+* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">write_skill_file</a>(name: str, file_path: str, file_content: str, propose: Optional[bool] = None) -> dict</code>
+* <code title="class SkillMetadata">SkillMetadata.<a href="./src/praisonai-agents/praisonaiagents/skills/models.py">from_properties</a>(props: SkillProperties) -> 'SkillMetadata'</code>
+* <code title="class SkillProperties">SkillProperties.<a href="./src/praisonai-agents/praisonaiagents/skills/models.py">idle_days</a>() -> Optional[float]</code>
+* <code title="class SkillProperties">SkillProperties.<a href="./src/praisonai-agents/praisonaiagents/skills/models.py">to_dict</a>() -> dict</code>
 * <code title="class SkillsConfig">SkillsConfig.<a href="./src/praisonai-agents/praisonaiagents/config/feature_configs.py">to_dict</a>() -> Dict[str, Any]</code>
 
 # Session
@@ -520,7 +568,6 @@ Methods:
 * <code title="class MCP">MCP.<a href="./src/praisonai-agents/praisonaiagents/mcp/mcp.py">get_prompts</a>() -> List[dict]</code>
 * <code title="class MCP">MCP.<a href="./src/praisonai-agents/praisonaiagents/mcp/mcp.py">get_resources</a>() -> List[dict]</code>
 * <code title="class MCP">MCP.<a href="./src/praisonai-agents/praisonaiagents/mcp/mcp.py">get_tools</a>() -> List[Callable]</code>
-* <code title="class MCP">MCP.<a href="./src/praisonai-agents/praisonaiagents/mcp/mcp.py">list_active_server_names</a>() -> set</code>
 * <code title="class MCP">MCP.<a href="./src/praisonai-agents/praisonaiagents/mcp/mcp.py">shutdown</a>()</code>
 * <code title="class MCP">MCP.<a href="./src/praisonai-agents/praisonaiagents/mcp/mcp.py">to_openai_tool</a>()</code>
 * <code title="class MCP">MCP.<a href="./src/praisonai-agents/praisonaiagents/mcp/mcp.py">with_tool_prefix</a>(prefix: str) -> 'MCP'</code>
@@ -684,7 +731,7 @@ Methods:
 
 Types:
 ```python
-from praisonaiagents import AgentAppConfig, AgentAppProtocol, AgentFlow, AgentManager, AgentOSConfig, AgentOSProtocol, AgentTeam, AutoApproveBackend, EmbeddingResult, RetryBackoffConfig, RunOutcome, __version__, aembedding, aembeddings, embedding, embeddings, get_dimensions
+from praisonaiagents import AgentAppConfig, AgentAppProtocol, AgentFlow, AgentManager, AgentOSConfig, AgentOSProtocol, AgentTeam, AutoApproveBackend, EmbeddingResult, RetryBackoffConfig, __version__, aembedding, aembeddings, embedding, embeddings, get_dimensions
 ```
 
 Methods:
@@ -707,7 +754,6 @@ Methods:
 * <code title="class AgentFlow">AgentFlow.<a href="./src/praisonai-agents/praisonaiagents/workflows/workflows.py">to_dict</a>() -> Dict[str, Any]</code>
 * <code title="class AgentFlow">AgentFlow.<a href="./src/praisonai-agents/praisonaiagents/workflows/workflows.py">verbose</a>() -> bool</code>
 * <code title="class AgentFlow">AgentFlow.<a href="./src/praisonai-agents/praisonaiagents/workflows/workflows.py">verbose</a>(value: bool)</code>
-* <code title="class AgentFlow">AgentFlow.<a href="./src/praisonai-agents/praisonaiagents/workflows/workflows.py">where_does_it_run</a>() -> str</code>
 * <code title="class AgentOSProtocol">AgentOSProtocol.<a href="./src/praisonai-agents/praisonaiagents/app/protocols.py">get_app</a>() -> Any</code>
 * <code title="class AgentOSProtocol">AgentOSProtocol.<a href="./src/praisonai-agents/praisonaiagents/app/protocols.py">serve</a>(host: Optional[str] = None, port: Optional[int] = None, reload: bool = False, **kwargs: Any) -> None</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">aannounce_completion</a>(agent_id: str, task_id: str, result: Any, success: bool = True, error: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None) -> None</code>
@@ -719,7 +765,6 @@ Methods:
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">arun_task</a>(task_id)</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">aspawn_sub_agent</a>(agent: Agent, task: Any, completion_callback: Optional[Callable[[SubAgentCompletionEvent], Any]] = None, metadata: Optional[Dict[str, Any]] = None) -> SpawnedSubAgent</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">astart</a>(content = None, return_dict = False, **kwargs)</code>
-* <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">astart_for_each</a>(inputs, **kwargs)</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">await_for_completions</a>(timeout: Optional[float] = None, agent_ids: Optional[List[str]] = None) -> List[SubAgentCompletionEvent]</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">clean_json_output</a>(output: str) -> str</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">clear_state</a>() -> None</code>
@@ -750,22 +795,16 @@ Methods:
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">run_all_tasks</a>()</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">run_task</a>(task_id)</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">save_output_to_file</a>(task, task_output)</code>
-* <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">save_session_state</a>(session_id: str, include_memory: bool = True) -> bool</code>
+* <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">save_session_state</a>(session_id: str, include_memory: bool = True) -> None</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">set_state</a>(key: str, value: Any) -> None</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">spawn_sub_agent</a>(agent: Agent, task: Any, completion_callback: Optional[Callable[[SubAgentCompletionEvent], Any]] = None, metadata: Optional[Dict[str, Any]] = None) -> SpawnedSubAgent</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">start</a>(content = None, return_dict = False, output = None, **kwargs)</code>
-* <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">start_for_each</a>(inputs, **kwargs)</code>
-* <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">stream_emitter</a>()</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">todo_list</a>()</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">update_plan_step_status</a>(step_id: str, status: str) -> bool</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">update_state</a>(updates: Dict) -> None</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">wait_for_completions</a>(timeout: Optional[float] = None, agent_ids: Optional[List[str]] = None) -> List[SubAgentCompletionEvent]</code>
-* <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">where_does_it_run</a>() -> str</code>
 * <code title="class AutoApproveBackend">AutoApproveBackend.<a href="./src/praisonai-agents/praisonaiagents/approval/backends.py">request_approval</a>(request: ApprovalRequest) -> ApprovalDecision</code>
 * <code title="class AutoApproveBackend">AutoApproveBackend.<a href="./src/praisonai-agents/praisonaiagents/approval/backends.py">request_approval_sync</a>(request: ApprovalRequest) -> ApprovalDecision</code>
-* <code title="class RunOutcome">RunOutcome.<a href="./src/praisonai-agents/praisonaiagents/agent/run_outcome.py">completed</a>(output: Optional[str] = None) -> 'RunOutcome'</code>
-* <code title="class RunOutcome">RunOutcome.<a href="./src/praisonai-agents/praisonaiagents/agent/run_outcome.py">from_exception</a>(exc: BaseException, output: Optional[str] = None) -> 'RunOutcome'</code>
-* <code title="class RunOutcome">RunOutcome.<a href="./src/praisonai-agents/praisonaiagents/agent/run_outcome.py">succeeded</a>() -> bool</code>
 * <code title="function">praisonaiagents.<a href="./src/praisonai-agents/praisonaiagents/embedding/embed.py">aembedding</a>(input: Union[str, List[str]], model: str = 'text-embedding-3-small', dimensions: Optional[int] = None, encoding_format: str = 'float', timeout: float = 600.0, api_key: Optional[str] = None, api_base: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None, **kwargs) -> EmbeddingResult</code>
 * <code title="function">praisonaiagents.<a href="./src/praisonai-agents/praisonaiagents/embedding/embed.py">aembeddings</a>(input: Union[str, List[str]], model: str = 'text-embedding-3-small', dimensions: Optional[int] = None, encoding_format: str = 'float', timeout: float = 600.0, api_key: Optional[str] = None, api_base: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None, **kwargs) -> EmbeddingResult</code>
 * <code title="function">praisonaiagents.<a href="./src/praisonai-agents/praisonaiagents/embedding/dimensions.py">get_dimensions</a>(model_name: str) -> int</code>
@@ -774,7 +813,7 @@ Methods:
 
 Types:
 ```python
-from praisonai import Agent, AgentApp, AgentOS, AnthropicManagedAgent, DB, HostedAgent, HostedAgentConfig, LocalAgent, LocalAgentConfig, LocalManagedAgent, LocalManagedConfig, ManagedAgent, ManagedConfig, __version__, arun, run
+from praisonai import Agent, AgentApp, AgentOS, AnthropicManagedAgent, CloudProvider, DB, Deploy, DeployConfig, DeployType, HostedAgent, HostedAgentConfig, LocalAgent, LocalAgentConfig, LocalManagedAgent, LocalManagedConfig, ManagedAgent, ManagedConfig, __version__, arun, run
 ```
 
 # CLI
@@ -842,13 +881,11 @@ Methods:
 * <code title="cli">praisonai managed list <a href="./src/praisonai/praisonai/cli/commands/managed.py">--help</a></code>
 * <code title="cli">praisonai managed managed-callback <a href="./src/praisonai/praisonai/cli/commands/managed.py">--help</a></code>
 * <code title="cli">praisonai managed multi <a href="./src/praisonai/praisonai/cli/commands/managed.py">--help</a></code>
-* <code title="cli">praisonai managed ps <a href="./src/praisonai/praisonai/cli/commands/managed.py">--help</a></code>
 * <code title="cli">praisonai managed restore <a href="./src/praisonai/praisonai/cli/commands/managed.py">--help</a></code>
 * <code title="cli">praisonai managed resume <a href="./src/praisonai/praisonai/cli/commands/managed.py">--help</a></code>
 * <code title="cli">praisonai managed run <a href="./src/praisonai/praisonai/cli/commands/managed.py">--help</a></code>
 * <code title="cli">praisonai managed save <a href="./src/praisonai/praisonai/cli/commands/managed.py">--help</a></code>
 * <code title="cli">praisonai managed show <a href="./src/praisonai/praisonai/cli/commands/managed.py">--help</a></code>
-* <code title="cli">praisonai managed stop <a href="./src/praisonai/praisonai/cli/commands/managed.py">--help</a></code>
 * <code title="cli">praisonai managed update <a href="./src/praisonai/praisonai/cli/commands/managed.py">--help</a></code>
 * <code title="cli">praisonai n8n export <a href="./src/praisonai/praisonai/cli/commands/n8n.py">--help</a></code>
 * <code title="cli">praisonai n8n import <a href="./src/praisonai/praisonai/cli/commands/n8n.py">--help</a></code>
@@ -903,6 +940,10 @@ Methods:
 * <code title="cli">praisonai schedule suggestion-dismiss <a href="./src/praisonai/praisonai/cli/commands/schedule.py">--help</a></code>
 * <code title="cli">praisonai schedule suggestion-propose <a href="./src/praisonai/praisonai/cli/commands/schedule.py">--help</a></code>
 * <code title="cli">praisonai schedule suggestions <a href="./src/praisonai/praisonai/cli/commands/schedule.py">--help</a></code>
+* <code title="cli">praisonai standardise check <a href="./src/praisonai/praisonai/cli/commands/standardise.py">--help</a></code>
+* <code title="cli">praisonai standardise fix <a href="./src/praisonai/praisonai/cli/commands/standardise.py">--help</a></code>
+* <code title="cli">praisonai standardise init <a href="./src/praisonai/praisonai/cli/commands/standardise.py">--help</a></code>
+* <code title="cli">praisonai standardise report <a href="./src/praisonai/praisonai/cli/commands/standardise.py">--help</a></code>
 * <code title="cli">praisonai validate check <a href="./src/praisonai/praisonai/cli/commands/validate.py">--help</a></code>
 * <code title="cli">praisonai validate schema <a href="./src/praisonai/praisonai/cli/commands/validate.py">--help</a></code>
 * <code title="cli">praisonai validate validate <a href="./src/praisonai/praisonai/cli/commands/validate.py">--help</a></code>

deploy/README.md

@@ -1,10 +0,0 @@
-# Deployment infra has moved
-
-Deployment assets are no longer at the monorepo root.
-
-| Asset | New location |
-|-------|----------------|
-| Gateway Helm chart | [`src/praisonai-bot/infra/helm/praisonai-gateway/`](../src/praisonai-bot/infra/helm/praisonai-gateway/) |
-| Agents API Helm, Compose, Starters | [`src/praisonai-deploy/infra/`](../src/praisonai-deploy/infra/) |
-
-See [`src/praisonai-deploy/infra/README.md`](../src/praisonai-deploy/infra/README.md).

docker/Dockerfile.chat

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=4.6.164" \
+    "praisonai>=4.6.155" \
     "praisonai[chat]" \
     "embedchain[github,youtube]"
 

docker/Dockerfile.dev

@@ -20,7 +20,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=4.6.164" \
+    "praisonai>=4.6.155" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \

docker/Dockerfile.ui

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=4.6.164" \
+    "praisonai>=4.6.155" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 

examples/doctor/ci_integration.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 CI Integration Example - Using Doctor in CI/CD pipelines
 

examples/endpoints_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 PraisonAI Endpoints Example
 

examples/execution/01_agent_execution_config.py

@@ -36,12 +36,6 @@ if __name__ == "__main__":
     print(f"Custom agent max_rpm: {agent.max_rpm}")
     print(f"Custom agent max_execution_time: {agent.max_execution_time}")
     print(f"Custom agent max_retry_limit: {agent.max_retry_limit}")
-
-    # max_rpm auto-creates a live RateLimiter (not just a stored number)
-    assert agent_rate_limited.max_rpm == 10
-    assert agent_rate_limited._rate_limiter is not None
-    assert agent_rate_limited._rate_limiter.requests_per_minute == 10
-    print(f"Rate-limited agent limiter: {agent_rate_limited._rate_limiter}")
     
     # Test custom agent
     print("\n--- Custom Execution ---")

examples/guardrail_example_fixed.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Fixed example demonstrating proper guardrail usage with PraisonAI Agents.
 This addresses the issues reported in issue #875.

examples/managed-agents/persistence/clickhouse_managed.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 ManagedAgent + ClickHouse Persistence — Real conversation with session resume.
 

examples/managed-agents/persistence/mongodb_managed.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 ManagedAgent + MongoDB Persistence — Real conversation with session resume.
 

examples/managed-agents/persistence/mysql_managed.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 ManagedAgent + MySQL Persistence — Real conversation with session resume.
 

examples/managed-agents/persistence/postgres_managed.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 ManagedAgent + PostgreSQL Persistence — Real conversation with session resume.
 

examples/managed-agents/persistence/redis_managed.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 ManagedAgent + Redis Persistence — Real conversation with session resume.
 

examples/managed-agents/persistence/sqlite_managed.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 ManagedAgent + SQLite Persistence — Real conversation with session resume.
 

examples/mcp_server/custom_tools_server.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Custom Tools MCP Server Example
 

examples/mcp_server/http_stream_server.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 HTTP Stream MCP Server Example
 

examples/mcp_server/mcp_client_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 MCP Client Example
 

examples/python/agents/context-agent.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Context Agent Example - Basic Usage
 

examples/python/agents/human-review-sequential-team.py

@@ -1,111 +0,0 @@
-"""
-Human Review Between Sequential AgentTeam Tasks
-================================================
-
-Demonstrates a human-in-the-loop review gate between sequential tasks using the
-existing ``on_task_complete`` hook — no new API required.
-
-IMPORTANT — two different ``on_task_complete`` hooks exist, with DIFFERENT
-signatures. Do not confuse them:
-
-    AgentTeam(hooks=MultiAgentHooksConfig(on_task_complete=fn))
-        -> fn(task, task_output)          # team-level; gets the Task and its output
-
-    Task(on_task_complete=fn)
-        -> fn(task_output)                # 1 param: just the TaskOutput
-        -> fn(task_output, metadata)      # 2+ params: TaskOutput + metadata dict
-                                          #   NOTE: NOT (task, task_output)
-
-This example uses the TEAM-level hook so we get ``(task, task_output)`` and can
-filter which tasks require review by ``task.name``.
-
-Approve / reject / edit:
-- approve -> return, workflow continues
-- reject  -> raise; see "stopping the workflow" note below
-- edit    -> mutate ``task_output.raw``; downstream tasks that read this task via
-             ``context=[...]`` pick up the edited text
-
-Stopping the workflow on reject
--------------------------------
-The TEAM-level hook logs and swallows exceptions, so a bare ``raise`` inside it
-does NOT stop the sequential run today. To hard-stop on reject, use the PER-TASK
-callback path with the 1-argument signature and ``fail_on_callback_error=True``
-(see ``review_output`` / ``t1_strict`` at the bottom of this file).
-"""
-
-from praisonaiagents import Agent, Task, AgentTeam
-from praisonaiagents.config.feature_configs import MultiAgentHooksConfig
-
-# Only these task names trigger a human review gate.
-REVIEW_TASKS = {"research"}
-
-
-# --- Team-level review gate: signature is (task, task_output) ---------------
-def review_gate(task, task_output):
-    if task.name not in REVIEW_TASKS:
-        return
-
-    print(f"\n--- Review: {task.name} ---\n{task_output.raw}\n")
-    choice = input("Approve (y), reject (n), edit (e)? ").strip().lower()
-
-    if choice == "n":
-        # NOTE: team-level hook swallows this; see per-task strict path below
-        # for a version that actually halts the workflow.
-        raise RuntimeError(f"Human rejected task '{task.name}'")
-
-    if choice == "e":
-        # task.result is the same object as task_output, so mutating .raw here
-        # propagates to downstream tasks that use context=[this_task].
-        task_output.raw = input("Edited output: ").strip()
-
-
-researcher = Agent(name="Researcher", role="Researcher", goal="Research", backstory="Expert")
-writer = Agent(name="Writer", role="Writer", goal="Write", backstory="Writer")
-
-t1 = Task(
-    name="research",
-    description="List 5 facts about {{topic}}",  # {{...}} is the substitution syntax
-    expected_output="5 bullets",
-    agent=researcher,
-)
-t2 = Task(
-    name="summary",
-    description="Write 3-sentence summary",
-    expected_output="3 sentences",
-    agent=writer,
-    context=[t1],  # reads the (possibly edited) output of t1
-)
-
-team = AgentTeam(
-    agents=[researcher, writer],
-    tasks=[t1, t2],
-    process="sequential",
-    variables={"topic": "REST APIs"},  # substituted into {{topic}} in task descriptions
-    hooks=MultiAgentHooksConfig(on_task_complete=review_gate),
-)
-
-
-# --- Alternative: per-task strict gate that HALTS on reject -----------------
-# Per-task Task.on_task_complete uses the 1-argument signature (task_output).
-# With fail_on_callback_error=True a raised exception re-raises and stops the run.
-def review_output(task_output):
-    print(f"\n--- Review output ---\n{task_output.raw}\n")
-    if input("Approve? (y/n) ").strip().lower() == "n":
-        raise RuntimeError("Human rejected output")
-
-
-t1_strict = Task(
-    name="research",
-    description="List 5 facts about {{topic}}",
-    expected_output="5 bullets",
-    agent=researcher,
-    variables={"topic": "REST APIs"},
-    on_task_complete=review_output,     # signature: (task_output)
-    fail_on_callback_error=True,        # required so reject halts the workflow
-)
-
-
-if __name__ == "__main__":
-    # NOTE: template values come from AgentTeam(variables=...), NOT start(inputs=...).
-    # start() forwards **kwargs but does not consume an ``inputs`` argument.
-    team.start()

examples/python/api/simple-mcp-server.py

@@ -1,15 +1,5 @@
-import threading
-import time
-
 from praisonaiagents import Agent
 
-
 if __name__ == "__main__":
     agent = Agent(name="TweetAgent", instructions="Create a Tweet based on the topic provided")
-    server = threading.Thread(
-        target=lambda: agent.launch(port=8080, protocol="mcp", path="/mcp"),
-        daemon=True,
-    )
-    server.start()
-    time.sleep(2)
-    print("MCP server started on http://127.0.0.1:8080/mcp")
+    agent.launch(port=8080, protocol="mcp", path="/mcp")

examples/python/concepts/csv-processing-agents.py

@@ -86,7 +86,7 @@ def method_1_simple_loop():
         agents=[loop_agent],
         tasks=[loop_task],
         process="workflow",
-        execution="balanced"        # max_iter=10 preset to prevent infinite loops
+        max_iter=10                 # Maximum iterations to prevent infinite loops
     )
     
     print(f"🚀 Starting loop processing of {csv_file}")

examples/python/concepts/knowledge-reranker-example.py

@@ -150,7 +150,7 @@ def main():
     agent = Agent(
         name="AI Research Assistant",
         instructions="You are an AI research assistant. Use your knowledge base to answer questions about artificial intelligence topics.",
-        knowledge={"sources": sample_documents, "rerank": True},
+        knowledge={**rerank_config, "sources": sample_documents},
         llm="gpt-4o-mini"
     )
     

examples/python/concepts/simple-csv-url-processor.py

@@ -64,7 +64,7 @@ def main():
         agents=[url_agent],
         tasks=[url_task],
         process="workflow",
-        execution="balanced"  # max_iter=10 preset; adjust for more URLs
+        max_iter=10  # Adjust based on how many URLs you have
     )
     
     print(f"🚀 Processing URLs from {csv_file}")

examples/python/custom_tools/minimal_latency_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Minimal Example: Latency Tracking for MCP Server
 

examples/python/failover_example.py

@@ -66,7 +66,7 @@ def demonstrate_failover():
         print(f"  {profile_info.get('name', 'unknown')}:")
         print(f"    Status: {profile_info.get('status', 'unknown')}")
         print(f"    Priority: {profile_info.get('priority', 'N/A')}")
-        print(f"    Failures: {profile_info.get('failure_count', 0)}")
+        print(f"    Last error: {profile_info.get('last_error') or 'none'}")
     print()
     
     # Get next available profile

examples/python/gateway_example.py

@@ -7,8 +7,7 @@ multiple agents and managing real-time communication.
 
 from praisonaiagents import Agent, GatewayConfig, SessionConfig
 
-# Configure the gateway using the typed SDK GatewayConfig.
-# In gateway.yaml, the optional ``gateway:`` block is validated at load time (#3050).
+# Configure the gateway
 gateway_config = GatewayConfig(
     host="127.0.0.1",
     port=8765,

examples/python/input/advanced_dynamic_input.py

@@ -141,7 +141,7 @@ class DynamicAgentSystem:
             agents=agents,
             tasks=tasks,
             process=process,
-            output="verbose" if inputs['depth'] == 'detailed' else "silent"
+            verbose=inputs['depth'] == 'detailed'
         )
         
         result = praison_agents.start()

examples/python/managed_agent_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Managed Agent Backend Example — Real end-to-end test.
 

examples/python/mcp/filesystem-mcp.py

@@ -7,12 +7,12 @@ allowed_dirs = [
     "/path/to/other/allowed/dir"
 ]
 
-# Pass the executable as the first token and the allowed directories as args
+# Use a single string command with allowed directories
 filesystem_agent = Agent(
     instructions="""You are a helpful assistant that can interact with the filesystem.
     Use the available tools when relevant to manage files and directories.""",
     llm="gpt-4o-mini",
-    tools=MCP("npx", args=["-y", "@modelcontextprotocol/server-filesystem", *allowed_dirs])
+    tools=MCP("npx -y @modelcontextprotocol/server-filesystem", args=allowed_dirs)
 )
 
 filesystem_agent.start("List files in the allowed directories") 

examples/python/memory/advanced-graph-memory-integration.py

@@ -67,7 +67,6 @@ agents_system = AgentTeam(
 print("Starting graph memory demonstration...")
 result = agents_system.start()
 
-result_text = str(result) if result is not None else ""
-print(f"\nGraph Memory Result: {result_text[:200]}...")
+print(f"\nGraph Memory Result: {result[:200]}...")
 print("\n✅ Graph memory integration complete!")
 print("Agent built knowledge graph and performed relationship-aware queries.")

examples/python/mongodb/mongodb_comprehensive_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Comprehensive MongoDB Integration Example for PraisonAI Agents
 

examples/python/mongodb/mongodb_tools_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 MongoDB Tools Example for PraisonAI Agents
 

examples/python/sessions/comprehensive-session-management.py

@@ -66,7 +66,7 @@ research_task1 = Task(
 agents_session1 = AgentTeam(
     agents=[research_agent],
     tasks=[research_task1],
-    output="verbose"
+    session=session1, output="verbose"
 )
 
 # Execute first session
@@ -105,7 +105,7 @@ analysis_task = Task(
 agents_session2 = AgentTeam(
     agents=[analysis_agent],
     tasks=[analysis_task], 
-    output="verbose"
+    session=session2, output="verbose"
 )
 
 print("Starting analysis session with previous context...")
@@ -155,7 +155,7 @@ synthesis_task = Task(
 agents_recovery = AgentTeam(
     agents=[synthesis_agent],
     tasks=[synthesis_task],
-    output="verbose"
+    session=recovery_session, output="verbose"
 )
 
 print("Starting recovery session with full context from previous sessions...")
@@ -205,7 +205,7 @@ review_task = Task(
 agents_reviewer = AgentTeam(
     agents=[review_agent],
     tasks=[review_task],
-    output="verbose"
+    session=reviewer_session, output="verbose"
 )
 
 print("Starting peer review session by different user...")

examples/python/stateful/memory-quality-example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Memory Quality Management Example
 

examples/python/tools/exa-tool/SocialMedia_Content_Agents/News_And_Podcast_Aggregator_Agent.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python
+# praisonai: skip=true
 # coding: utf-8
 
 # # News and Podcast Aggregator Agent using Agents

examples/python/tools/searxng/searxng-search.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 SearxNG Search Tool Example
 

examples/python/tools/trafilatura/custom_trafilatura_tools.py

@@ -77,35 +77,13 @@ class TrafilaturaTools:
             except ValueError:
                 # Not an IP address, continue with domain validation
                 pass
-
+            
             # Block common internal domains
             if any(hostname.endswith(domain) for domain in ['.local', '.internal', '.localdomain']):
                 return False
-
+            
             # Block metadata service endpoints
-            if hostname in ['169.254.169.254', 'metadata.google.internal']:
-                return False
-
-            # Resolve the hostname and reject if any address is internal. The
-            # checks above only inspect IP *literals*, so a plain domain (or an
-            # encoded form like a decimal IP or "<internal-ip>.nip.io") still
-            # passes even though it resolves to an internal address. Resolving
-            # here closes that SSRF bypass, mirroring the resolve-and-check
-            # approach already used in praisonaiagents/tools/file_tools.py.
-            import socket
-            default_port = 443 if parsed.scheme == 'https' else 80
-            try:
-                addrinfos = socket.getaddrinfo(hostname, parsed.port or default_port)
-            except socket.gaierror:
-                # Hostname does not resolve; treat it as unsafe.
-                return False
-            for addrinfo in addrinfos:
-                resolved = ipaddress.ip_address(addrinfo[4][0])
-                if (resolved.is_private or resolved.is_reserved
-                        or resolved.is_loopback or resolved.is_link_local):
-                    return False
-
-            return True
+            return hostname not in ['169.254.169.254', 'metadata.google.internal']
             
         except Exception:
             return False
@@ -279,17 +257,7 @@ class TrafilaturaTools:
             "newspaper": None,
             "spider": None
         }
-
-        # Validate the URL once before any fetcher runs so the newspaper and
-        # requests paths below are protected against SSRF, just like the
-        # trafilatura path (which validates inside extract_content).
-        if not self._validate_url(url):
-            error = {"error": f"Invalid or unsafe URL: {url}"}
-            comparison["trafilatura"] = error
-            comparison["newspaper"] = error
-            comparison["spider"] = error
-            return comparison
-
+        
         # Get Trafilatura extraction
         try:
             comparison["trafilatura"] = self.extract_content(url)

examples/recipes/creator_suite/brief_generator_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 AI Brief Generator Example
 

examples/recipes/creator_suite/hook_generator_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 AI Hook Generator Example
 

examples/recipes/creator_suite/news_crawler_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 AI News Crawler Example
 

examples/recipes/creator_suite/script_writer_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 AI Script Writer Example
 

examples/recipes/example_llm_recipes.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Example: LLM-based Recipes
 

examples/registry/http_registry_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 HTTP Recipe Registry Example
 

examples/run_all_examples.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """Run all examples and collect PASS/SKIP/FAIL results."""
 import subprocess
 import sys

examples/serve/a2a_server_client.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 A2A (Agent-to-Agent) Server and Client Example
 

examples/serve/a2u_events_stream.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 A2U (Agent-to-User) Event Stream Example
 

examples/serve/agents_as_api_router.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Multi-Agent Router as HTTP API Example
 

examples/serve/endpoints_unified_client.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Unified Endpoints Client Example
 

examples/serve/mcp_http_server.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 MCP HTTP Server Example
 

examples/serve/serve_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 PraisonAI Recipe Server Example
 

examples/serve/tools_as_mcp_server.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Tools as MCP Server Example
 

examples/serve/unified_server.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Unified Server Example
 

examples/terminal_bench/job_code_smoke.yaml

@@ -14,9 +14,9 @@ datasets:
     # A small verified subset for a cheap smoke run. Verify against the registry
     # with `harbor datasets list` before editing.
     task_names:
-      - terminal-bench/build-pmars
-      - terminal-bench/bn-fit-modify
-      - terminal-bench/break-filter-js-from-html
+      - hello-world
+      - fix-permissions
+      - csv-to-parquet
 
 agents:
   - import_path: examples.terminal_bench.praisonai_code_agent:PraisonAICodeAgent

examples/terminal_bench/praisonai_code_agent.py

@@ -13,14 +13,15 @@ Usage:
         -n 4
 
 Architecture:
-    Harbor Container → `praisonai code -p --output json "TASK" --dangerously-skip-approval`
+    Harbor Container → `praisonai code "TASK" --dangerously-skip-approval` (headless)
 
 Notes:
     - `--dangerously-skip-approval` sets PRAISON_APPROVAL_MODE=auto +
       PRAISONAI_TOOL_SAFETY=off so the assistant runs fully autonomously in the
       container (no approval hang in a non-TTY session).
-    - The JSON envelope provides token, cost, session, and status metadata while
-      the real exit status still surfaces install/auth/startup failures.
+    - `praisonai code` normally exits 0 and Harbor grades by task verification,
+      so a benchmark miss does not fail the run — but the real exit status is
+      propagated so genuine install/auth/startup failures still surface.
     - The base `praisonai` package is sufficient; heavy `code` extras are not
       required (ACP tools degrade gracefully).
 
@@ -28,7 +29,6 @@ Dependencies:
     pip install harbor praisonai praisonaiagents
 """
 
-import json
 import shlex
 
 try:
@@ -81,19 +81,16 @@ class PraisonAICodeAgent(BaseInstalledAgent):
         model = self.model_name or "openai/gpt-4o-mini"
 
         command = (
-            "log_file=$(mktemp /tmp/praisonai_code.XXXXXX); "
-            "chmod 600 \"$log_file\"; "
-            f"praisonai code -p --output json {shlex.quote(instruction)} "
+            f"praisonai code {shlex.quote(instruction)} "
             f"--dangerously-skip-approval "
             f"--model {shlex.quote(model)} "
-            "> \"$log_file\" 2>&1; "
+            "> /tmp/praisonai_code.log 2>&1; "
             # Capture the real exit status so install/auth/startup failures still
             # surface instead of being silently masked (Harbor otherwise records a
             # completed attempt for a crashed agent).
             "status=$?; "
-            # Echo the envelope so Harbor captures it for post-run accounting.
-            "cat \"$log_file\"; "
-            "rm -f \"$log_file\"; "
+            # Tee the log into a stable path so populate_context_post_run can read it.
+            "cp /tmp/praisonai_code.log /tmp/praisonai_code_run.log 2>/dev/null || true; "
             # `praisonai code` normally exits 0 (Harbor grades by task
             # verification), so a genuine benchmark miss won't fail here — but a
             # nonzero status means the assistant itself failed to run.
@@ -103,35 +100,23 @@ class PraisonAICodeAgent(BaseInstalledAgent):
         # `--ae` / job YAML env vars arrive via BaseAgent.extra_env and are wired
         # into the container exec context by Harbor Trial, so no per-exec `env=`
         # is needed here.
-        result = await self.exec_as_agent(
+        await self.exec_as_agent(
             environment,
             command=command,
         )
-        self._last_stdout = getattr(result, "stdout", "") or ""
 
     def populate_context_post_run(self, context: AgentContext) -> None:
-        """Parse the headless JSON envelope into Harbor's accounting fields."""
-        envelope = None
-        for line in reversed(getattr(self, "_last_stdout", "").splitlines()):
-            try:
-                candidate = json.loads(line)
-            except (TypeError, ValueError, json.JSONDecodeError):
-                continue
-            if isinstance(candidate, dict) and "status" in candidate:
-                envelope = candidate
-                break
+        """`praisonai code` exposes no machine-readable metrics headlessly.
 
-        usage = envelope.get("usage", {}) if envelope else {}
-        context.n_input_tokens = usage.get("in")
-        context.n_output_tokens = usage.get("out")
-        context.cost_usd = usage.get("cost")
+        Record identifying metadata; token/cost accounting is not available from
+        the CLI's mixed stdout, so we leave those fields unset rather than guess.
+        """
         context.metadata = {
             "framework": "praisonai",
             "agent_type": "code-cli",
             "agent_name": self.name(),
             "model": self.model_name,
-            "session_id": envelope.get("session_id") if envelope else None,
-            "status": envelope.get("status") if envelope else "unknown",
+            "log_path": "/tmp/praisonai_code.log",
         }
 
 

examples/terminal_bench/praisonai_external_agent.py

@@ -34,7 +34,6 @@ except ImportError as e:
 try:
     from praisonaiagents import Agent
     from praisonaiagents.approval import get_approval_registry, AutoApproveBackend
-    from praisonaiagents.config.feature_configs import ExecutionConfig
 except ImportError as e:
     raise ImportError(
         f"PraisonAI not installed: {e}\n"
@@ -42,13 +41,6 @@ except ImportError as e:
     ) from e
 
 
-TB_EXECUTION = ExecutionConfig(
-    max_tool_calls_per_turn=80,
-    max_iter=40,
-    max_steps=80,
-)
-
-
 class PraisonAIExternalAgent(BaseAgent):
     """External PraisonAI agent that drives a Harbor container environment."""
 
@@ -150,14 +142,26 @@ class PraisonAIExternalAgent(BaseAgent):
                 ),
                 tools=[bash_tool],
                 llm=self.model_name or "openai/gpt-4o-mini",
-                execution=TB_EXECUTION,
             )
 
-            # Execute one deliberately long coding turn. Harbor's hidden verifier
-            # is the only completion authority; model or pytest text is not.
+            # Execute the agent with outer loop to handle premature stopping
             print(f"🚀 PraisonAI Agent starting task: {instruction[:100]}...")
             result = await agent.achat(instruction)
-            print("✅ PraisonAI Agent completed task")
+            for _iter in range(19):
+                result_str = str(result)
+                # Stop if test passed
+                if any(sig in result_str.lower() for sig in [
+                    " passed", "passed ", "test passed", "all tests pass", "1 passed"
+                ]):
+                    break
+                result = await agent.achat(
+                    "The task is NOT complete yet — keep working. Run bash_tool commands now. "
+                    "If you haven't already: (1) read all files in /app/, "
+                    "(2) run the test to see the exact failure, "
+                    "(3) implement a fix, (4) run the test again. "
+                    "Repeat until the test passes. What is your next bash_tool command?"
+                )
+            print(f"✅ PraisonAI Agent completed task")
             
             # Populate Harbor context with metadata
             self._populate_context(agent, context, result)
@@ -199,10 +203,6 @@ class PraisonAIExternalAgent(BaseAgent):
                 "tools_used": ["bash_tool"],
                 "framework": "praisonai",
                 "version": self.version(),
-                "stop_reason": getattr(agent, "last_stop_reason", None),
-                "max_tool_calls_per_turn": TB_EXECUTION.max_tool_calls_per_turn,
-                "max_iter": TB_EXECUTION.max_iter,
-                "max_steps": TB_EXECUTION.max_steps,
             }
             
         except Exception as e:
@@ -218,4 +218,4 @@ if __name__ == "__main__":
     print("  --model openai/gpt-4o-mini")
     print()
     print("Dependencies:")
-    print("  pip install harbor praisonaiagents")
+    print("  pip install harbor praisonaiagents")

examples/terminal_bench/test_adapter_config.py

@@ -1,39 +0,0 @@
-"""Static regression checks for the in-tree Harbor adapter configuration."""
-
-from pathlib import Path
-
-import yaml
-
-
-EXAMPLES = Path(__file__).parent
-
-
-def test_external_adapter_sets_coding_execution_budget():
-    source = (EXAMPLES / "praisonai_external_agent.py").read_text(encoding="utf-8")
-
-    assert "ExecutionConfig" in source
-    assert "max_tool_calls_per_turn=80" in source
-    assert "max_iter=40" in source
-    assert "max_steps=80" in source
-
-
-def test_external_adapter_does_not_guess_completion_from_pytest_text():
-    source = (EXAMPLES / "praisonai_external_agent.py").read_text(encoding="utf-8")
-
-    assert '"1 passed"' not in source
-    assert '"test passed"' not in source
-
-
-def test_smoke_yaml_uses_terminal_bench_21_registry_ids():
-    job = yaml.safe_load(
-        (EXAMPLES / "job_code_smoke.yaml").read_text(encoding="utf-8")
-    )
-    names = job["datasets"][0]["task_names"]
-
-    assert names
-    assert all(name.startswith("terminal-bench/") for name in names)
-    assert names == [
-        "terminal-bench/build-pmars",
-        "terminal-bench/bn-fit-modify",
-        "terminal-bench/break-filter-js-from-html",
-    ]

examples/terminal_bench/test_agent_comparison.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Agent Comparison Test - Run 5 tasks with both wrapper and direct agent
 

examples/terminal_bench/test_basic.py

@@ -14,18 +14,18 @@ def test_imports():
     """Test that all required modules can be imported."""
     try:
         from praisonaiagents import Agent
-        print("[OK] Agent imported successfully")
+        print("✅ Agent imported successfully")
         
         from praisonaiagents.tools import execute_command
-        print("[OK] execute_command tool imported successfully")
+        print("✅ execute_command tool imported successfully")
         
         from praisonaiagents.approval import get_approval_registry, AutoApproveBackend
-        print("[OK] Approval system imported successfully")
+        print("✅ Approval system imported successfully")
         
         return True
         
     except ImportError as e:
-        print(f"[FAIL] Import failed: {ascii(e)}")
+        print(f"❌ Import failed: {e}")
         return False
 
 def test_agent_creation():
@@ -40,11 +40,11 @@ def test_agent_creation():
         )
         
         assert agent.name == 'test-agent'
-        print("[OK] Agent creation successful")
+        print("✅ Agent creation successful")
         return True
         
     except Exception as e:
-        print(f"[FAIL] Agent creation failed: {ascii(e)}")
+        print(f"❌ Agent creation failed: {e}")
         return False
 
 def test_approval_system():
@@ -55,11 +55,11 @@ def test_approval_system():
         registry = get_approval_registry()
         registry.set_backend(AutoApproveBackend())
         
-        print("[OK] Approval system configuration successful")
+        print("✅ Approval system configuration successful")
         return True
         
     except Exception as e:
-        print(f"[FAIL] Approval system test failed: {ascii(e)}")
+        print(f"❌ Approval system test failed: {e}")
         return False
 
 def test_external_agent_import():
@@ -80,11 +80,11 @@ def test_external_agent_import():
         
         # Now try to import our agent
         import praisonai_external_agent
-        print("[OK] External agent import successful")
+        print("✅ External agent import successful")
         return True
         
     except Exception as e:
-        print(f"[FAIL] External agent import failed: {ascii(e)}")
+        print(f"❌ External agent import failed: {e}")
         return False
 
 def test_multi_agent_import():
@@ -104,11 +104,11 @@ def test_multi_agent_import():
         sys.modules['harbor.models.agent.context'] = MagicMock()
         
         import multi_agent_example
-        print("[OK] Multi-agent example import successful")
+        print("✅ Multi-agent example import successful")
         return True
         
     except Exception as e:
-        print(f"[FAIL] Multi-agent example import failed: {ascii(e)}")
+        print(f"❌ Multi-agent example import failed: {e}")
         return False
 
 def test_wrapper_agent_import():
@@ -128,11 +128,11 @@ def test_wrapper_agent_import():
         sys.modules['harbor.models.agent.context'] = MagicMock()
         
         import praisonai_wrapper_agent
-        print("[OK] Wrapper agent import successful (CLI-based approach)")
+        print("✅ Wrapper agent import successful (CLI-based approach)")
         return True
         
     except Exception as e:
-        print(f"[FAIL] Wrapper agent import failed: {ascii(e)}")
+        print(f"❌ Wrapper agent import failed: {e}")
         return False
 
 if __name__ == "__main__":
@@ -152,19 +152,19 @@ if __name__ == "__main__":
     total = len(tests)
     
     for test_name, test_func in tests:
-        print(f"\n[TEST] {test_name}...")
+        print(f"\n🧪 Testing {test_name}...")
         try:
             if test_func():
                 passed += 1
         except Exception as e:
-            print(f"[FAIL] Test {test_name} crashed: {ascii(e)}")
+            print(f"❌ Test {test_name} crashed: {e}")
     
     print("\n" + "=" * 55)
     print(f"Results: {passed}/{total} tests passed")
     
     if passed == total:
-        print("[OK] ALL BASIC TESTS PASSED!")
+        print("🎉 ALL BASIC TESTS PASSED!")
         print("The Terminal-Bench integration components are properly structured.")
     else:
-        print("[FAIL] Some tests failed - check output above")
+        print("❌ Some tests failed - check output above")
         sys.exit(1)

examples/tools/external/hackernews/tool.py

@@ -30,11 +30,9 @@ def main():
     else:
         print(f"Found {len(stories)} top stories:")
         for story in stories:
-            title = story.get("title") or "N/A"
-            url = story.get("url") or "N/A"
-            print(f"  - {title[:50]}...")
+            print(f"  - {story.get('title', 'N/A')[:50]}...")
             print(f"    Score: {story.get('score', 'N/A')} | Comments: {story.get('descendants', 'N/A')}")
-            print(f"    URL: {url[:60]}...")
+            print(f"    URL: {story.get('url', 'N/A')[:60]}...")
             print()
     
     print("✅ Hacker News tool working correctly!")

examples/yaml/gateway.yaml

@@ -19,9 +19,6 @@ agents:
 channels:
   telegram:
     token: "${TELEGRAM_BOT_TOKEN}"
-    # allow_shell: true
-    # auto_approve_shell: false
-    # approval_channel: "123456789"   # Telegram chat ID for shell approvals
     routing:
       dm: "personal"
       group: "support"
@@ -29,9 +26,6 @@ channels:
 
   discord:
     token: "${DISCORD_BOT_TOKEN}"
-    # allow_shell: true
-    # auto_approve_shell: false
-    # approval_channel: "9876543210"  # Discord channel ID (or use home_channel)
     routing:
       dm: "personal"
       channel: "support"
@@ -40,8 +34,6 @@ channels:
   slack:
     token: "${SLACK_BOT_TOKEN}"
     app_token: "${SLACK_APP_TOKEN}"
-    allow_shell: true
-    auto_approve_shell: true
     routing:
       dm: "personal"
       channel: "support"

examples/yaml/teams/research-writer/README.md

@@ -1,64 +0,0 @@
-# Simple Sequential Team (YAML)
-
-A minimal 2-agent sequential team: a **researcher** gathers facts, then a
-**writer** summarizes them. This is the copy-paste starting point for the most
-common multi-agent pattern (2–5 agents, run in order).
-
-```
-research_task  ->  summary_task
- (researcher)       (writer)
-```
-
-## Files
-
-| File | Purpose |
-|------|---------|
-| `agents.yaml` | Roles (who) + their tasks (what); tasks run in declaration order |
-
-> **Which loader applies?** This example uses the canonical single-file format
-> consumed by `AgentsGenerator.generate_crew_and_kickoff()`
-> (`src/praisonai/praisonai/agents_generator.py`). Agents live under `roles:`,
-> each with nested `tasks:`. **Tasks run in the order they are declared** — the
-> researcher's task first, then the writer's. (An optional top-level
-> `dependencies:` block is included to document intent and mirror the canonical
-> fixture, but the roles-file loader sequences by declaration order, so keep
-> tasks in the order you want them to run.) No new loader module is required —
-> this is the existing YAML path.
-
-## Run it
-
-```bash
-export OPENAI_API_KEY=sk-...
-praisonai examples/yaml/teams/research-writer/agents.yaml
-```
-
-This positional-file form is the canonical roles-file entry point. From Python
-the equivalent is `praisonai.run("agents.yaml")` (see
-`src/praisonai/praisonai/_entrypoint.py`), which dispatches to the same
-`AgentsGenerator`.
-
-Change the subject by editing the `topic:` line in `agents.yaml` (interpolated
-into every `{topic}` placeholder).
-
-## When to use this vs a workflow YAML
-
-| You need… | Use | Example |
-|-----------|-----|---------|
-| 2–5 agents, sequential/hierarchical | **This** (`roles:` + `tasks:`) | `agents.yaml` here |
-| Routing by classifier output | workflow YAML | `../../workflows/routing_workflow.yaml` |
-| Parallel branches | workflow YAML | `../../workflows/parallel_workflow.yaml` |
-| Loops / planning / memory | workflow YAML | `../../workflows/complete_workflow.yaml` |
-
-## Python equivalent
-
-```python
-from praisonaiagents import Agent, Task, PraisonAIAgents
-
-researcher = Agent(role="Senior Researcher", goal="Find accurate information")
-writer = Agent(role="Report Writer", goal="Turn research into summaries")
-
-t1 = Task(description="Research renewable energy and list 5 key facts", agent=researcher)
-t2 = Task(description="Write a 3-sentence summary from the research", agent=writer, context=[t1])
-
-PraisonAIAgents(agents=[researcher, writer], tasks=[t1, t2]).start()
-```

examples/yaml/teams/research-writer/agents.yaml

@@ -1,34 +0,0 @@
-# yaml-language-server: $schema=https://docs.praison.ai/schemas/agents.schema.json
-# Minimal sequential team: researcher -> writer
-# Run: praisonai examples/yaml/teams/research-writer/agents.yaml
-
-framework: "praisonai"
-topic: "renewable energy"
-
-roles:
-  researcher:
-    role: "Senior Researcher"
-    goal: "Find accurate information about {topic}"
-    backstory: "Expert at concise, factual research."
-    tasks:
-      research_task:
-        description: "Research {topic} and list 5 key facts."
-        expected_output: "A bullet list of 5 facts."
-
-  writer:
-    role: "Report Writer"
-    goal: "Turn research into readable summaries about {topic}"
-    backstory: "Clear technical writer."
-    tasks:
-      summary_task:
-        description: "Write a 3-sentence executive summary from the research."
-        expected_output: "3 sentences, plain text."
-
-# Ordering is by task declaration order above (researcher's task runs first,
-# then the writer's), which is how the roles-file loader sequences tasks.
-# The optional `dependencies:` block below mirrors the canonical fixture
-# (src/praisonai/tests/agents.yaml) and documents intent; the roles-file
-# loader does not consume it, so keep tasks in the order you want them run.
-dependencies:
-  - task: summary_task
-    depends_on: research_task

examples/yaml/workflows/remote_sandbox_workflow.yaml

@@ -1,40 +0,0 @@
-# Run a whole workflow's shell/file tools inside ONE shared remote sandbox.
-#
-#   praisonai examples/yaml/workflows/remote_sandbox_workflow.yaml
-#
-# `run_on:` is the only line that differs from a normal local workflow. Every
-# step shares the same sandbox and /workspace, so the file the writer creates
-# is there for the reader. Orchestration still runs on your machine, and the
-# sandbox is torn down when the run finishes.
-#
-# Providers: docker | e2b | modal | daytona | flyio | tenki | local
-#   - docker needs a local Docker daemon and nothing else
-#   - e2b / modal / daytona / flyio need that provider's API key
-#
-# See what is still running:  praisonai managed ps
-# Reclaim strays:             praisonai managed stop --all
-
-name: remote-sandbox-demo
-run_on: docker
-
-agents:
-  writer:
-    role: File Writer
-    goal: Write files into the shared workspace
-    instructions: >
-      You have write_file and execute_command running on a remote Linux
-      sandbox. Use them; never say you cannot run commands.
-
-  reader:
-    role: File Reader
-    goal: Read files back out of the shared workspace
-    instructions: >
-      You have read_file and execute_command running on the same remote
-      sandbox the writer used. Use them.
-
-steps:
-  - agent: writer
-    action: "Use write_file to put exactly 'hello from step 1' in /workspace/note.txt"
-
-  - agent: reader
-    action: "Use read_file on /workspace/note.txt and report its exact contents"

scripts/apply_e2e_batch3_code_fixes.py

@@ -9,9 +9,15 @@ ROOT = Path(__file__).resolve().parents[1]
 def _prepend_skip(rel: str) -> None:
     path = ROOT / rel
     text = path.read_text(encoding="utf-8")
-    if "# praisonai: skip=true" in text.splitlines()[:3]:
+    lines = text.splitlines(keepends=True)
+    if any("# praisonai: skip=true" in ln for ln in lines[:3]):
         return
-    path.write_text("# praisonai: skip=true\n" + text, encoding="utf-8")
+    # Preserve a shebang on the first line so direct execution still works.
+    if lines and lines[0].startswith("#!"):
+        lines.insert(1, "# praisonai: skip=true\n")
+        path.write_text("".join(lines), encoding="utf-8")
+    else:
+        path.write_text("# praisonai: skip=true\n" + text, encoding="utf-8")
 
 
 def fix_knowledge_reranker() -> None:
@@ -133,6 +139,9 @@ def main() -> None:
     fix_knowledge_reranker()
     print("fixed knowledge-reranker")
 
+    fix_mcp_env_examples()
+    print("fixed MCP environment examples")
+
     # advanced-task-management TaskOutput import
     p = ROOT / "examples/python/tasks/advanced-task-management.py"
     if p.exists():

scripts/apply_e2e_batch3_fixes.py

@@ -1,12 +1,13 @@
 """Apply batch-3 E2E fixes: skip directives for non-runnable examples."""
 from __future__ import annotations
 
+import argparse
 import json
 import re
 from pathlib import Path
 
 ROOT = Path(__file__).resolve().parents[1]
-REPORT = Path(__file__).resolve().parents[2] / "PraisonAI-main-e2e" / "examples-e2e-reports" / "post_merge_20260723_132751" / "report.json"
+DEFAULT_REPORT = Path(__file__).resolve().parents[2] / "PraisonAI-main-e2e" / "examples-e2e-reports" / "post_merge_20260723_132751" / "report.json"
 
 SKIP_LINE = "# praisonai: skip=true"
 SKIP_RE = re.compile(r"^#\s*praisonai:\s*skip\s*=", re.MULTILINE)
@@ -55,13 +56,29 @@ def add_skip(path: Path) -> bool:
     text = path.read_text(encoding="utf-8", errors="ignore")
     if SKIP_RE.search("\n".join(text.splitlines()[:30])):
         return False
-    new_text = SKIP_LINE + "\n" + text.lstrip("\ufeff")
+    text = text.lstrip("\ufeff")
+    lines = text.splitlines(keepends=True)
+    # Preserve a shebang on the first line so direct execution still works.
+    if lines and lines[0].startswith("#!"):
+        lines.insert(1, SKIP_LINE + "\n")
+        new_text = "".join(lines)
+    else:
+        new_text = SKIP_LINE + "\n" + text
     path.write_text(new_text, encoding="utf-8")
     return True
 
 
 def main() -> None:
-    report = json.loads(REPORT.read_text(encoding="utf-8"))
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "report",
+        nargs="?",
+        type=Path,
+        default=DEFAULT_REPORT,
+        help="Path to the E2E report.json (defaults to the audit report path).",
+    )
+    args = parser.parse_args()
+    report = json.loads(args.report.read_text(encoding="utf-8"))
     targets: set[str] = set()
     for it in report.get("results", []):
         if it.get("status") in ("failed", "timeout"):

scripts/check_c14_deploy_imports.sh

@@ -1,55 +0,0 @@
-#!/usr/bin/env bash
-# C14 import-direction gate for praisonai-deploy.
-set -euo pipefail
-
-cd "$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-
-CODE_ROOT="${C14_CODE_ROOT:-src/praisonai-code/praisonai_code}"
-DEPLOY_ROOT="${C14_DEPLOY_ROOT:-src/praisonai-deploy/praisonai_deploy}"
-
-ANY_WRAPPER_RE='(^[[:space:]]*from praisonai([[:space:]]|\.)|^[[:space:]]*import praisonai($|\.))'
-ANY_CODE_RE='(^from praisonai_code([[:space:]]|\.)|^import praisonai_code($|\.))'
-ANY_DEPLOY_RE='(^[[:space:]]*from praisonai_deploy([[:space:]]|\.)|^[[:space:]]*import praisonai_deploy($|\.))'
-
-echo "== C14 praisonai_deploy wrapper import gate (must be zero outside bridges) =="
-if command -v rg >/dev/null 2>&1; then
-  MATCHES="$(rg -n "$ANY_WRAPPER_RE" "$DEPLOY_ROOT" --glob '*.py' 2>/dev/null | grep -v '_wrapper_bridge.py' | grep -v '_bootstrap.py' | grep -v '_code_bridge.py' || true)"
-else
-  MATCHES="$(grep -rEn --include='*.py' "$ANY_WRAPPER_RE" "$DEPLOY_ROOT" 2>/dev/null | grep -v '_wrapper_bridge.py' | grep -v '_bootstrap.py' | grep -v '_code_bridge.py' || true)"
-fi
-if [ -n "$MATCHES" ]; then
-  echo "$MATCHES"
-  echo "FAIL: praisonai_deploy imports the praisonai wrapper"
-  exit 1
-fi
-echo "deploy wrapper import gate ok"
-
-echo "== C14 praisonai_deploy module-level praisonai_code import gate =="
-if command -v rg >/dev/null 2>&1; then
-  MATCHES="$(rg -n "$ANY_CODE_RE" "$DEPLOY_ROOT" --glob '*.py' 2>/dev/null | grep -v '_code_bridge.py' | grep -v '_plugin_registry.py' || true)"
-else
-  MATCHES="$(grep -rEn --include='*.py' "$ANY_CODE_RE" "$DEPLOY_ROOT" 2>/dev/null | grep -v '_code_bridge.py' | grep -v '_plugin_registry.py' || true)"
-fi
-if [ -n "$MATCHES" ]; then
-  echo "$MATCHES"
-  echo "FAIL: module-level praisonai_code import in praisonai_deploy"
-  exit 1
-fi
-echo "deploy code import gate ok"
-
-echo "== C14 praisonai-code hot-path gate (no praisonai_deploy at module level) =="
-for f in \
-  "$CODE_ROOT/cli/main.py" \
-  "$CODE_ROOT/cli/app.py" \
-  "$CODE_ROOT/cli/commands/run.py" \
-  "$CODE_ROOT/cli/commands/chat.py" \
-  "$CODE_ROOT/cli/commands/code.py"
-do
-  if [ -f "$f" ] && head -n 80 "$f" | grep -E "$ANY_DEPLOY_RE" 2>/dev/null; then
-    echo "FAIL: module-level praisonai_deploy import in code hot path $f"
-    exit 1
-  fi
-done
-echo "code hot-path gate ok"
-
-echo "C14 import gates passed"

scripts/check_c7_imports.sh

@@ -18,9 +18,7 @@ for f in \
   "$ROOT/cli/app.py" \
   "$ROOT/cli/commands/run.py" \
   "$ROOT/cli/commands/chat.py" \
-  "$ROOT/cli/commands/code.py" \
-  "$ROOT/cli/interactive/async_tui.py" \
-  "$ROOT/cli/interactive/core.py"
+  "$ROOT/cli/commands/code.py"
 do
   if grep -E "$HOT_PATH_RE" "$f" 2>/dev/null; then
     echo "FAIL: module-level wrapper import in $f"

scripts/check_helm_charts.sh

@@ -1,60 +0,0 @@
-#!/usr/bin/env bash
-# Lint and template-render all Helm charts under package infra/ trees.
-set -euo pipefail
-
-ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-
-if ! command -v helm >/dev/null 2>&1; then
-  echo "FAIL: helm CLI not found (install via https://helm.sh/docs/intro/install/)"
-  exit 1
-fi
-
-HELM_ROOTS=(
-  "$ROOT/src/praisonai-bot/infra/helm"
-  "$ROOT/src/praisonai-deploy/infra/helm"
-)
-
-charts=()
-for helm_root in "${HELM_ROOTS[@]}"; do
-  if [ ! -d "$helm_root" ]; then
-    continue
-  fi
-  shopt -s nullglob
-  for chart in "$helm_root"/*/; do
-    if [ -f "${chart}Chart.yaml" ]; then
-      charts+=("$chart")
-    fi
-  done
-  shopt -u nullglob
-done
-
-if [ ${#charts[@]} -eq 0 ]; then
-  echo "No charts found under package infra/helm trees"
-  exit 1
-fi
-
-for chart in "${charts[@]}"; do
-  name="$(basename "$chart")"
-  echo "== helm lint: $name =="
-  helm lint "$chart"
-
-  echo "== helm template: $name =="
-  case "$name" in
-    praisonai-gateway)
-      helm template "ci-smoke-$name" "$chart" \
-        --set auth.existingSecret=ci-smoke-auth \
-        >/dev/null
-      ;;
-    praisonai-agents-api)
-      helm template "ci-smoke-$name" "$chart" \
-        --set auth.existingSecret=ci-smoke-auth \
-        --set postgres.auth.existingSecret=ci-smoke-postgres \
-        >/dev/null
-      ;;
-    *)
-      helm template "ci-smoke-$name" "$chart" >/dev/null
-      ;;
-  esac
-done
-
-echo "Helm chart gates passed (${#charts[@]} chart(s))"

src/praisonai-agents/AGENTS.md

@@ -140,7 +140,7 @@ The **agentic terminal CLI** (`run`, `chat`, `code`, warm runtime, CLI backends,
 
 **Monorepo bootstrap:** `praisonai._bootstrap.ensure_praisonai_code()` adds sibling `src/praisonai-code` to `sys.path` so `PYTHONPATH=src/praisonai-agents:src/praisonai` works without an explicit code entry.
 
-**Install order (CI and local dev):** `praisonai-agents` → `praisonai-code` → `praisonai-bot` → `praisonai-train` → `praisonai-browser` → `praisonai-mcp` → `praisonai-sandbox` → `praisonai-deploy` → `praisonai` (see `.github/actions/install-monorepo-packages`).
+**Install order (CI and local dev):** `praisonai-agents` → `praisonai-code` → `praisonai` (see `.github/actions/install-monorepo-packages`).
 
 **Invocation paths that must remain valid:**
 

src/praisonai-agents/DOCS_PARITY.md

@@ -18,76 +18,76 @@ This report compares **Python SDK feature categories** against **Python document
 | Category | Features | Docs | Lines |
 |----------|----------|------|-------|
 | ✅ AGUI | 1 | 2 | 420 |
-| ✅ Agent | 22 | 50 | 15813 |
-| ✅ Agent-to-Agent (A2A) | 1 | 7 | 2996 |
-| ✅ Agent-to-User (A2U) | 1 | 3 | 689 |
-| ✅ Approval | 1 | 5 | 2537 |
+| ✅ Agent | 21 | 45 | 14056 |
+| ✅ Agent-to-Agent (A2A) | 1 | 7 | 2965 |
+| ✅ Agent-to-User (A2U) | 1 | 3 | 585 |
+| ✅ Approval | 1 | 5 | 2286 |
 | ✅ Audio | 2 | 12 | 1000 |
-| ✅ Auto Generation | 5 | 11 | 3274 |
-| ✅ Autonomy | 3 | 7 | 2756 |
-| ✅ Bots | 7 | 31 | 13366 |
+| ✅ Auto Generation | 5 | 10 | 2868 |
+| ✅ Autonomy | 3 | 7 | 2707 |
+| ✅ Bots | 7 | 28 | 11165 |
 | ✅ Budget | 1 | 1 | 287 |
-| ✅ CLI | 5 | 121 | 36059 |
+| ✅ CLI | 5 | 119 | 33595 |
 | ✅ Chunking | 2 | 2 | 385 |
 | ✅ Citations | 2 | 1 | 202 |
-| ✅ Code Execution | 2 | 14 | 4583 |
+| ✅ Code Execution | 2 | 13 | 3907 |
 | ✅ Conditions | 1 | 3 | 1179 |
-| ✅ Configuration | 3 | 8 | 3047 |
-| ✅ Context Management | 16 | 34 | 13396 |
+| ✅ Configuration | 3 | 7 | 2772 |
+| ✅ Context Management | 16 | 34 | 13204 |
 | ✅ Deep Research | 8 | 2 | 587 |
 | ✅ Display | 6 | 3 | 741 |
 | ✅ Embeddings | 6 | 23 | 2049 |
-| ✅ Evaluation | 1 | 7 | 2905 |
+| ✅ Evaluation | 1 | 7 | 2902 |
 | ✅ Events | 1 | 2 | 749 |
-| ✅ Execution | 3 | 4 | 1562 |
-| ✅ Failover | 2 | 1 | 432 |
-| ✅ Files | 2 | 7 | 2275 |
-| ✅ Flow | 1 | 3 | 788 |
-| ✅ Gateway | 7 | 74 | 27180 |
-| ✅ Guardrails | 4 | 4 | 2025 |
-| ✅ Handoffs | 11 | 6 | 2563 |
-| ✅ Hooks | 2 | 9 | 4434 |
+| ✅ Execution | 3 | 4 | 1528 |
+| ✅ Failover | 2 | 1 | 400 |
+| ✅ Files | 2 | 6 | 1964 |
+| ✅ Flow | 1 | 3 | 777 |
+| ✅ Gateway | 7 | 52 | 18862 |
+| ✅ Guardrails | 4 | 4 | 1673 |
+| ✅ Handoffs | 11 | 6 | 2454 |
+| ✅ Hooks | 2 | 9 | 3985 |
 | ✅ Image | 1 | 11 | 1255 |
-| ✅ Knowledge | 4 | 13 | 4333 |
-| ✅ LLM | 3 | 15 | 5192 |
-| ✅ Loops | 4 | 5 | 1422 |
-| ✅ MCP | 1 | 61 | 13993 |
-| ✅ Memory | 6 | 18 | 7070 |
+| ✅ Knowledge | 4 | 13 | 4160 |
+| ✅ LLM | 3 | 14 | 4767 |
+| ✅ Loops | 4 | 4 | 1202 |
+| ✅ MCP | 1 | 58 | 13322 |
+| ✅ Memory | 6 | 17 | 6635 |
 | ✅ OCR | 2 | 1 | 237 |
-| ✅ Observability | 2 | 23 | 2814 |
+| ✅ Observability | 2 | 23 | 2779 |
 | ✅ Optimizer | 1 | 2 | 792 |
-| ✅ Output | 3 | 5 | 1242 |
+| ✅ Output | 3 | 5 | 1158 |
 | ✅ Parallel Execution | 3 | 2 | 497 |
-| ✅ Planning | 6 | 6 | 1549 |
-| ✅ Plugins | 8 | 4 | 2858 |
-| ✅ Prompts | 2 | 9 | 1965 |
-| ✅ Providers | 1 | 56 | 7743 |
+| ✅ Planning | 6 | 6 | 1545 |
+| ✅ Plugins | 8 | 3 | 1879 |
+| ✅ Prompts | 2 | 8 | 1726 |
+| ✅ Providers | 1 | 55 | 7459 |
 | ✅ Query | 1 | 2 | 736 |
-| ✅ RAG | 5 | 15 | 3003 |
+| ✅ RAG | 5 | 15 | 2936 |
 | ✅ Realtime | 2 | 5 | 668 |
 | ✅ Reflection | 3 | 3 | 680 |
-| ✅ Retrieval | 2 | 5 | 1054 |
+| ✅ Retrieval | 2 | 5 | 1044 |
 | ✅ Routing | 1 | 2 | 430 |
-| ✅ Sandbox | 5 | 7 | 3202 |
-| ✅ Security | 1 | 3 | 3332 |
-| ✅ Sessions | 4 | 18 | 7158 |
-| ✅ Skills | 6 | 15 | 5638 |
-| ✅ Tasks | 2 | 6 | 2819 |
+| ✅ Sandbox | 5 | 6 | 2700 |
+| ✅ Security | 1 | 3 | 2908 |
+| ✅ Sessions | 4 | 13 | 5286 |
+| ✅ Skills | 6 | 13 | 4946 |
+| ✅ Tasks | 2 | 6 | 2743 |
 | ✅ Telemetry | 1 | 2 | 604 |
-| ✅ Templates | 1 | 8 | 1663 |
-| ✅ Tools | 12 | 141 | 41246 |
+| ✅ Templates | 1 | 8 | 1657 |
+| ✅ Tools | 12 | 132 | 37592 |
 | ✅ Tracing | 3 | 2 | 139 |
-| ✅ Vector Store | 1 | 12 | 1211 |
+| ✅ Vector Store | 1 | 12 | 1193 |
 | ✅ Video | 2 | 6 | 649 |
 | ✅ Vision | 2 | 1 | 329 |
-| ✅ Web | 3 | 9 | 2467 |
-| ✅ Workflows | 5 | 16 | 6593 |
+| ✅ Web | 3 | 8 | 2055 |
+| ✅ Workflows | 5 | 16 | 6546 |
 
 ## Documentation Without Features
 
 These docs exist but don't match any implemented feature category:
 
-- ℹ️ Database (42 docs, 6713 lines)
+- ℹ️ Database (40 docs, 6184 lines)
 - ℹ️ Documents (1 docs, 787 lines)
 
 ---

src/praisonai-agents/praisonaiagents/__init__.py

@@ -143,9 +143,9 @@ _LAZY_IMPORTS = {
     'has_toolset': ('praisonaiagents.toolsets', 'has_toolset'),
 
     # Model-family-aware harness (base prompt + edit-format selection)
-    'HarnessProfile': ('praisonaiagents.model_harness.profiles', 'HarnessProfile'),
-    'resolve_harness': ('praisonaiagents.model_harness.profiles', 'resolve_harness'),
-    'register_profile': ('praisonaiagents.model_harness.profiles', 'register_profile'),
+    'HarnessProfile': ('praisonaiagents.model_harness', 'HarnessProfile'),
+    'resolve_harness': ('praisonaiagents.model_harness', 'resolve_harness'),
+    'register_profile': ('praisonaiagents.model_harness', 'register_profile'),
 
     # Run outcomes - typed validation and agent execution results
     'AgentRunOutcome': ('praisonaiagents.run_outcome', 'AgentRunOutcome'),
@@ -258,7 +258,6 @@ _LAZY_IMPORTS = {
     
     # Agent classes
     'Agent': ('praisonaiagents.agent.agent', 'Agent'),
-    'RunOutcome': ('praisonaiagents.agent.run_outcome', 'RunOutcome'),
     'RetryBackoffConfig': ('praisonaiagents.agent.retry_utils', 'RetryBackoffConfig'),
     'BudgetExceededError': ('praisonaiagents.errors', 'BudgetExceededError'),
     
@@ -304,10 +303,9 @@ _LAZY_IMPORTS = {
     'CodeAgent': ('praisonaiagents.agent.code_agent', 'CodeAgent'),
     'CodeConfig': ('praisonaiagents.agent.code_agent', 'CodeConfig'),
     
-    # AgentTeam (primary) / AgentManager, PraisonAIAgents (aliases)
+    # AgentTeam (primary) / AgentManager (alias)
     'AgentTeam': ('praisonaiagents.agents.agents', 'AgentTeam'),
     'AgentManager': ('praisonaiagents.agents.agents', 'AgentManager'),  # Silent alias
-    'PraisonAIAgents': ('praisonaiagents.agents.agents', 'PraisonAIAgents'),  # Silent alias (pre-1.0 name)
     # Note: 'Agents' is handled by _custom_handler for deprecation warning
     'Task': ('praisonaiagents.task.task', 'Task'),
     'AutoAgents': ('praisonaiagents.agents.autoagents', 'AutoAgents'),
@@ -426,7 +424,6 @@ _LAZY_IMPORTS = {
     'WebConfig': ('praisonaiagents.config.feature_configs', 'WebConfig'),
     'OutputConfig': ('praisonaiagents.config.feature_configs', 'OutputConfig'),
     'ExecutionConfig': ('praisonaiagents.config.feature_configs', 'ExecutionConfig'),
-    'PreCompactionMemoryFlushConfig': ('praisonaiagents.config.feature_configs', 'PreCompactionMemoryFlushConfig'),
     'TemplateConfig': ('praisonaiagents.config.feature_configs', 'TemplateConfig'),
     'CachingConfig': ('praisonaiagents.config.feature_configs', 'CachingConfig'),
     'HooksConfig': ('praisonaiagents.config.feature_configs', 'HooksConfig'),
@@ -841,11 +838,9 @@ __all__ = [
     
     # Core classes - the essentials
     'Agent',
-    'RunOutcome',
     'RetryBackoffConfig',
     'AgentTeam',  # Primary class for multi-agent coordination (v1.0+)
     'AgentManager',  # Silent alias for AgentTeam
-    'PraisonAIAgents',  # Silent alias for AgentTeam (pre-1.0 name)
     'Agents',  # Deprecated alias for AgentTeam (emits warning)
     'Task',
     

src/praisonai-agents/praisonaiagents/_lazy.py

@@ -28,11 +28,8 @@ from typing import Any, Callable, Dict, Optional, Tuple
 
 _logger = logging.getLogger(__name__)
 
-# Global cache lock for thread-safe access.
-# Reentrant so that a lazy import which triggers another lazy import on the
-# same thread (e.g. a package attribute that re-exports from a submodule via
-# its own __getattr__) degrades to redundant work instead of self-deadlocking.
-_cache_lock = threading.RLock()
+# Global cache lock for thread-safe access
+_cache_lock = threading.Lock()
 
 # Global module cache
 _module_cache: Dict[str, Any] = {}

src/praisonai-agents/praisonaiagents/_logging.py

@@ -4,6 +4,7 @@ This module consolidates all logging configuration in one place to avoid duplica
 """
 
 import os
+import json
 import logging
 from typing import Any, Dict, List, Optional, Union
 
@@ -195,9 +196,6 @@ class StructuredFormatter(logging.Formatter):
             extra = {k: v for k, v in record.extra_data.items() if k not in self._STANDARD_FIELDS}
             log_data.update(extra)
 
-        # Deferred: json is only needed for opt-in structured logging
-        import json
-
         return json.dumps(log_data)
 
 

src/praisonai-agents/praisonaiagents/agent/__init__.py

@@ -37,15 +37,6 @@ def __getattr__(name):
         from .interrupt import InterruptController
         _lazy_cache[name] = InterruptController
         return InterruptController
-    if name in ('RunOutcome', 'TerminalReason'):
-        from . import run_outcome as _run_outcome_module
-        value = getattr(_run_outcome_module, name)
-        _lazy_cache[name] = value
-        return value
-    if name == 'prompt_prefix_signature':
-        from .prompt_cache import prompt_prefix_signature
-        _lazy_cache[name] = prompt_prefix_signature
-        return prompt_prefix_signature
     
     # Specialized agents - lazy loaded (import rich)
     if name == 'ImageAgent':
@@ -224,9 +215,6 @@ __all__ = [
     'Heartbeat',
     'HeartbeatConfig',
     'InterruptController',
-    'RunOutcome',
-    'TerminalReason',
-    'prompt_prefix_signature',
     'ImageAgent',
     'VideoAgent',
     'VideoConfig',

src/praisonai-agents/praisonaiagents/agent/async_memory_mixin.py

@@ -7,6 +7,7 @@ async capabilities following the AsyncMemoryProtocol.
 """
 
 import asyncio
+import logging
 from typing import List, Dict, Any, Optional, Union
 from praisonaiagents._logging import get_logger
 from ..memory.protocols import AsyncMemoryProtocol
@@ -84,36 +85,21 @@ class AsyncMemoryMixin:
         if not hasattr(self, '_memory_instance') or self._memory_instance is None:
             logger.debug("No memory configured for async search")
             return []
-
-        # Shared adapters must receive the configured identity explicitly.
-        # FileMemory is already bound to a user-specific path and accepts these
-        # as harmless protocol kwargs.
-        scoped_kwargs = dict(kwargs)
-        config = getattr(self, "_memory_config", None)
-        user_id = getattr(config, "user_id", None)
-        session_id = getattr(config, "session_id", None)
-        if user_id:
-            scoped_kwargs["user_id"] = user_id
-        if session_id:
-            scoped_kwargs["session_id"] = session_id
-            metadata_filter = dict(scoped_kwargs.get("metadata_filter") or {})
-            metadata_filter["session_id"] = session_id
-            scoped_kwargs["metadata_filter"] = metadata_filter
             
         # Check if memory adapter supports async operations
         if isinstance(self._memory_instance, AsyncMemoryProtocol):
             try:
                 if memory_type == "long_term":
-                    return await self._memory_instance.asearch_long_term(query, limit, **scoped_kwargs)
+                    return await self._memory_instance.asearch_long_term(query, limit, **kwargs)
                 else:
-                    return await self._memory_instance.asearch_short_term(query, limit, **scoped_kwargs)
+                    return await self._memory_instance.asearch_short_term(query, limit, **kwargs)
             except Exception as e:
                 logger.error(f"Error in async memory search: {e}")
                 return []
         else:
             # Fallback: run sync memory operations in thread pool
             return await self._run_memory_in_thread(
-                "search", query, memory_type, limit=limit, **scoped_kwargs
+                "search", query, memory_type, limit=limit, **kwargs
             )
     
     async def _run_memory_in_thread(
@@ -230,4 +216,4 @@ class AsyncMemoryMixin:
                 )
                 return False
             return True
-        return False
+        return False

src/praisonai-agents/praisonaiagents/agent/async_safety.py

@@ -5,9 +5,8 @@ This module provides dual-lock abstractions that automatically select
 the appropriate lock type based on the execution context (sync vs async).
 """
 import asyncio
-import copy
 import threading
-from typing import Any
+from typing import Any, Optional, Union
 from contextlib import contextmanager, asynccontextmanager
 from weakref import WeakKeyDictionary
 
@@ -40,12 +39,6 @@ class DualLock:
         """Initialize with separate threading and asyncio locks."""
         self._thread_lock = threading.RLock()  # Re-entrant lock to handle nested acquisitions
         self._async_locks = WeakKeyDictionary()  # Per-event-loop async locks
-
-    def __deepcopy__(self, memo):
-        """Return an unlocked primitive with no event-loop state sharing."""
-        result = type(self)()
-        memo[id(self)] = result
-        return result
     
     @contextmanager
     def sync(self):
@@ -110,33 +103,6 @@ class AsyncSafeState:
     def __init__(self, initial_value: Any = None):
         self.value = initial_value
         self._lock = DualLock()
-        self._activity_lock = threading.Lock()
-        self._async_holders = 0
-        self._copying = False
-
-    def __deepcopy__(self, memo):
-        """Copy protected state, rejecting overlap with asynchronous access."""
-        result = type(self).__new__(type(self))
-        memo[id(self)] = result
-        with self._activity_lock:
-            if self._async_holders:
-                raise RuntimeError(
-                    "Cannot deepcopy AsyncSafeState during asynchronous access"
-                )
-            if self._copying:
-                raise RuntimeError("AsyncSafeState deepcopy is already in progress")
-            self._copying = True
-        try:
-            with self.lock():
-                result.value = copy.deepcopy(self.value, memo)
-        finally:
-            with self._activity_lock:
-                self._copying = False
-        result._lock = DualLock()
-        result._activity_lock = threading.Lock()
-        result._async_holders = 0
-        result._copying = False
-        return result
         
     @contextmanager 
     def lock(self):
@@ -148,25 +114,7 @@ class AsyncSafeState:
     async def async_lock(self):
         """Acquire lock in async context."""
         async with self._lock.async_lock():
-            self._begin_async_access()
-            try:
-                yield self.value
-            finally:
-                self._end_async_access()
-
-    def _begin_async_access(self) -> None:
-        """Register async access unless a synchronous copy is in progress."""
-        with self._activity_lock:
-            if self._copying:
-                raise RuntimeError(
-                    "Cannot access AsyncSafeState during synchronous deepcopy"
-                )
-            self._async_holders += 1
-
-    def _end_async_access(self) -> None:
-        """Unregister one active asynchronous accessor."""
-        with self._activity_lock:
-            self._async_holders -= 1
+            yield self.value
             
     def __enter__(self):
         """Support for synchronous context manager protocol (backward compatibility)."""
@@ -182,20 +130,12 @@ class AsyncSafeState:
         """Support for asynchronous context manager protocol."""
         async_lock = self._lock._get_async_lock()
         await async_lock.acquire()
-        try:
-            self._begin_async_access()
-        except Exception:
-            async_lock.release()
-            raise
         return self.value
         
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """Support for asynchronous context manager protocol."""
         async_lock = self._lock._get_async_lock()
-        try:
-            self._end_async_access()
-        finally:
-            async_lock.release()
+        async_lock.release()
         return None
             
     def get(self) -> Any:
@@ -204,4 +144,4 @@ class AsyncSafeState:
         
     def is_async_context(self) -> bool:
         """Check if we're in an async context.""" 
-        return self._lock.is_async_context()
+        return self._lock.is_async_context()

src/praisonai-agents/praisonaiagents/agent/autonomy.py

@@ -34,6 +34,7 @@ Usage:
 from dataclasses import dataclass, field
 from typing import Optional, Dict, Any, List, Set
 from enum import Enum
+import logging
 from praisonaiagents._logging import get_logger
 
 logger = get_logger(__name__)
@@ -106,11 +107,8 @@ class AutonomyConfig:
         track_changes: Whether to track filesystem changes via shadow git.
             Defaults to True when level="full_auto", False otherwise.
             When enabled, agent.undo()/redo()/diff() become available.
-        sandbox: Optional SandboxConfig, carried for forward compatibility.
-            NOT IMPLEMENTED: nothing currently reads this field, and no sandbox
-            is auto-enabled at any autonomy level. To isolate execution, set it
-            on the agent itself -- Agent(sandbox=...) -- or run the whole
-            workflow remotely with AgentFlow(run_on="docker").
+        sandbox: Optional SandboxConfig for execution isolation.
+            When level="full_auto" and sandbox is None, subprocess sandbox is auto-enabled.
         snapshot_dir: Directory for snapshot storage. Defaults to ~/.praisonai/snapshots.
     
     Usage::
@@ -265,6 +263,17 @@ class AutonomySignal(str, Enum):
         )
         super().__init_subclass__(**kwargs)
 
+def _warn_autonomy_signal():
+    """Emit deprecation warning when AutonomySignal is accessed."""
+    from ..utils.deprecation import warn_deprecated_param
+    warn_deprecated_param(
+        "AutonomySignal",
+        since="1.0.0",
+        removal="2.0.0",
+        alternative="use EscalationSignal from praisonaiagents.escalation.types instead",
+        stacklevel=4
+    )
+
 class AutonomyTrigger:
     """Detects signals from prompts for autonomy decisions.
     

src/praisonai-agents/praisonaiagents/agent/context_agent.py

@@ -22,6 +22,7 @@ from typing import Optional, Any, Dict, Union, List, TYPE_CHECKING
 # Lazy imports for performance - these are only loaded when needed
 _subprocess = None
 _glob = None
+_ast = None
 _asyncio = None
 
 def _get_subprocess():
@@ -40,6 +41,14 @@ def _get_glob():
         _glob = glob
     return _glob
 
+def _get_ast():
+    """Lazy import ast to avoid import-time overhead."""
+    global _ast
+    if _ast is None:
+        import ast
+        _ast = ast
+    return _ast
+
 def _get_asyncio():
     """Lazy import asyncio to avoid import-time overhead."""
     global _asyncio

src/praisonai-agents/praisonaiagents/agent/cost_persistence.py

@@ -12,6 +12,7 @@ Usage::
 """
 
 import json
+import logging
 from praisonaiagents._logging import get_logger
 import os
 import time

src/praisonai-agents/praisonaiagents/agent/deep_research_agent.py

@@ -34,6 +34,7 @@ Example:
 """
 
 import os
+import logging
 from praisonaiagents._logging import get_logger
 import time
 import asyncio

src/praisonai-agents/praisonaiagents/agent/durable.py

@@ -1,448 +0,0 @@
-"""Opt-in durable tool-loop context backed by :class:`RunJournal`."""
-
-from __future__ import annotations
-
-import asyncio
-import contextvars
-import inspect
-import json
-import threading
-from typing import Any, Callable, Dict, List, Optional, Tuple
-from uuid import uuid4
-
-from ..errors import ToolExecutionError
-from ..runtime.journal import (
-    JournalEvent,
-    KIND_ITERATION,
-    KIND_MODEL_DECISION,
-    KIND_TOOL_CALL,
-    KIND_TOOL_RESULT,
-    RunJournal,
-)
-
-
-_active_durable_run: contextvars.ContextVar[Optional["DurableRunContext"]] = (
-    contextvars.ContextVar("praisonai_active_durable_run", default=None)
-)
-_active_idempotency_key: contextvars.ContextVar[Optional[str]] = (
-    contextvars.ContextVar("praisonai_idempotency_key", default=None)
-)
-
-
-def _json_safe(value: Any) -> Any:
-    try:
-        return json.loads(json.dumps(value))
-    except (TypeError, ValueError):
-        return json.loads(json.dumps(value, default=str))
-
-
-def _tool_result_content(result: Any) -> str:
-    if result is None:
-        return "Function returned an empty output"
-    try:
-        return json.dumps(result)
-    except (TypeError, ValueError):
-        return json.dumps({"result": str(result)})
-
-
-def _accepts_idempotency_key(execute_tool_fn: Callable) -> bool:
-    """Return whether an executor accepts the optional durable key contract."""
-    try:
-        parameters = inspect.signature(execute_tool_fn).parameters.values()
-    except (TypeError, ValueError):
-        return False
-    return any(
-        parameter.name == "idempotency_key"
-        or parameter.kind == inspect.Parameter.VAR_KEYWORD
-        for parameter in parameters
-    )
-
-
-class DurableRunContext:
-    """Per-turn journal state; safe for parallel tool-call wrappers."""
-
-    def __init__(
-        self,
-        journal: RunJournal,
-        run_id: str,
-        *,
-        replaying: bool,
-    ) -> None:
-        self.journal = journal
-        self.run_id = run_id
-        self.replaying = replaying
-        self._lock = threading.RLock()
-        self._replay = journal.replay_index(run_id)
-        events = journal.events(run_id)
-        self._next_seq = max((event.seq for event in events), default=-1) + 1
-        self._restored = False
-        self._closed = False
-        self._results_by_tool_call_id: Dict[str, Any] = {}
-        self._pending_by_call_id: Dict[str, Tuple[int, str, Dict[str, Any], str]] = {}
-        self._pending_by_fingerprint: Dict[str, Tuple[int, str, Dict[str, Any], str]] = {}
-        self._recorded_iterations = set()
-        for event in events:
-            if event.kind == KIND_TOOL_RESULT:
-                tool_call_id = event.payload.get("tool_call_id")
-                if tool_call_id:
-                    self._results_by_tool_call_id[str(tool_call_id)] = event.payload.get(
-                        "result"
-                    )
-            elif event.kind == KIND_ITERATION:
-                self._recorded_iterations.add(
-                    int(event.payload.get("index", event.seq))
-                )
-
-        for event in events:
-            if event.kind != KIND_TOOL_CALL:
-                continue
-            call_id = str(event.payload.get("tool_call_id") or "")
-            if not call_id or call_id in self._results_by_tool_call_id:
-                continue
-            name = str(event.payload.get("name") or "")
-            args = event.payload.get("args") or {}
-            key = str(
-                event.payload.get("idempotency_key")
-                or f"{self.run_id}:{event.seq}:{name}"
-            )
-            pending = (event.seq, call_id, args, key)
-            self._pending_by_call_id[call_id] = pending
-            self._pending_by_fingerprint[self._fingerprint(name, args)] = pending
-
-        self._resume_completed_steps = len(self._recorded_iterations)
-
-    @property
-    def completed_steps(self) -> int:
-        return len(self._recorded_iterations)
-
-    @staticmethod
-    def _fingerprint(function_name: str, arguments: Dict[str, Any]) -> str:
-        return f"{function_name}:{json.dumps(_json_safe(arguments), sort_keys=True)}"
-
-    def restore_messages(self, messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-        """Append completed decision/result pairs once, before the next model call."""
-        if not self.replaying or self._restored:
-            return messages
-
-        existing_ids = set()
-        for message in messages:
-            for tool_call in message.get("tool_calls") or []:
-                if isinstance(tool_call, dict) and tool_call.get("id"):
-                    existing_ids.add(str(tool_call["id"]))
-
-        for seq in sorted({key[0] for key in self._replay}):
-            decision = self._replay.get((seq, KIND_MODEL_DECISION))
-            result = self._replay.get((seq, KIND_TOOL_RESULT))
-            if not decision or result is None:
-                continue
-            message = decision.get("message")
-            tool_call_id = result.get("tool_call_id")
-            if not isinstance(message, dict) or not tool_call_id:
-                continue
-            if str(tool_call_id) in existing_ids:
-                continue
-            messages.append(_json_safe(message))
-            messages.append(
-                {
-                    "role": "tool",
-                    "tool_call_id": str(tool_call_id),
-                    "content": _tool_result_content(result.get("result")),
-                }
-            )
-            existing_ids.add(str(tool_call_id))
-
-        self._restored = True
-        return messages
-
-    def _allocate_step(
-        self,
-        function_name: str,
-        arguments: Dict[str, Any],
-        tool_call_id: Optional[str],
-    ) -> Tuple[int, str, str]:
-        with self._lock:
-            requested_call_id = str(tool_call_id) if tool_call_id is not None else None
-            pending = (
-                self._pending_by_call_id.pop(requested_call_id, None)
-                if requested_call_id
-                else None
-            )
-            fingerprint = self._fingerprint(function_name, arguments)
-            if pending is None and self.replaying:
-                pending = self._pending_by_fingerprint.pop(fingerprint, None)
-            if pending is not None:
-                seq, call_id, _args, idempotency_key = pending
-                self._pending_by_call_id.pop(call_id, None)
-                self._pending_by_fingerprint.pop(fingerprint, None)
-                return seq, call_id, idempotency_key
-
-            seq = self._next_seq
-            self._next_seq += 1
-            call_id = str(tool_call_id or f"{self.run_id}-tool-{seq}")
-            idempotency_key = f"{self.run_id}:{seq}:{function_name}"
-            safe_arguments = _json_safe(arguments)
-            message = {
-                "role": "assistant",
-                "content": "",
-                "tool_calls": [
-                    {
-                        "id": call_id,
-                        "type": "function",
-                        "function": {
-                            "name": function_name,
-                            "arguments": json.dumps(safe_arguments),
-                        },
-                    }
-                ],
-            }
-            self.journal.append(
-                JournalEvent(
-                    self.run_id,
-                    seq,
-                    KIND_MODEL_DECISION,
-                    {"message": message},
-                )
-            )
-            self.journal.append(
-                JournalEvent(
-                    self.run_id,
-                    seq,
-                    KIND_TOOL_CALL,
-                    {
-                        "name": function_name,
-                        "args": safe_arguments,
-                        "tool_call_id": call_id,
-                        "idempotency_key": idempotency_key,
-                    },
-                )
-            )
-            return seq, call_id, idempotency_key
-
-    def _record_result(
-        self,
-        seq: int,
-        tool_call_id: str,
-        result: Any,
-        iteration_index: Optional[int],
-    ) -> Any:
-        safe_result = _json_safe(result)
-        with self._lock:
-            self.journal.append(
-                JournalEvent(
-                    self.run_id,
-                    seq,
-                    KIND_TOOL_RESULT,
-                    {"tool_call_id": tool_call_id, "result": safe_result},
-                )
-            )
-            if iteration_index is None:
-                global_iteration = max(self._recorded_iterations, default=-1) + 1
-            else:
-                global_iteration = self._resume_completed_steps + int(iteration_index)
-            if global_iteration not in self._recorded_iterations:
-                self.journal.append(
-                    JournalEvent(
-                        self.run_id,
-                        global_iteration,
-                        KIND_ITERATION,
-                        {"index": global_iteration},
-                    )
-                )
-                self._recorded_iterations.add(global_iteration)
-            self._results_by_tool_call_id[tool_call_id] = safe_result
-            self._replay[(seq, KIND_TOOL_RESULT)] = {
-                "tool_call_id": tool_call_id,
-                "result": safe_result,
-            }
-        return safe_result
-
-    def _record_terminal_failure(
-        self,
-        seq: int,
-        tool_call_id: str,
-        error: ToolExecutionError,
-        iteration_index: Optional[int],
-    ) -> None:
-        """Persist a fatal tool outcome and make the run non-resumable."""
-        self._record_result(
-            seq,
-            tool_call_id,
-            {
-                "error": str(error),
-                "error_type": type(error).__name__,
-                "is_retryable": bool(error.is_retryable),
-                "terminal": True,
-            },
-            iteration_index,
-        )
-        self.finalize("failed")
-
-    def wrap_sync(self, execute_tool_fn: Optional[Callable]) -> Optional[Callable]:
-        if execute_tool_fn is None:
-            return None
-
-        def execute(function_name, arguments, tool_call_id=None, **kwargs):
-            iteration_index = kwargs.pop("_durable_iteration_index", None)
-            call_id = str(tool_call_id) if tool_call_id is not None else None
-            if call_id and call_id in self._results_by_tool_call_id:
-                return self._results_by_tool_call_id[call_id]
-            seq, call_id, idempotency_key = self._allocate_step(
-                function_name, arguments, tool_call_id
-            )
-            token = _active_idempotency_key.set(idempotency_key)
-            try:
-                call_kwargs = dict(kwargs)
-                call_kwargs["tool_call_id"] = tool_call_id
-                if _accepts_idempotency_key(execute_tool_fn):
-                    call_kwargs["idempotency_key"] = idempotency_key
-                result = execute_tool_fn(function_name, arguments, **call_kwargs)
-            except ToolExecutionError as exc:
-                if not exc.is_retryable:
-                    self._record_terminal_failure(
-                        seq, call_id, exc, iteration_index
-                    )
-                raise
-            except Exception as exc:
-                result = {"error": str(exc)}
-            finally:
-                _active_idempotency_key.reset(token)
-            return self._record_result(seq, call_id, result, iteration_index)
-
-        return execute
-
-    def wrap_async(self, execute_tool_fn: Optional[Callable]) -> Optional[Callable]:
-        if execute_tool_fn is None:
-            return None
-
-        async def execute(function_name, arguments, tool_call_id=None, **kwargs):
-            iteration_index = kwargs.pop("_durable_iteration_index", None)
-            call_id = str(tool_call_id) if tool_call_id is not None else None
-            if call_id and call_id in self._results_by_tool_call_id:
-                return self._results_by_tool_call_id[call_id]
-            seq, call_id, idempotency_key = await asyncio.to_thread(
-                self._allocate_step, function_name, arguments, tool_call_id
-            )
-            token = _active_idempotency_key.set(idempotency_key)
-            try:
-                call_kwargs = dict(kwargs)
-                call_kwargs["tool_call_id"] = tool_call_id
-                if _accepts_idempotency_key(execute_tool_fn):
-                    call_kwargs["idempotency_key"] = idempotency_key
-                result = execute_tool_fn(function_name, arguments, **call_kwargs)
-                if inspect.isawaitable(result):
-                    result = await result
-            except ToolExecutionError as exc:
-                if not exc.is_retryable:
-                    await asyncio.to_thread(
-                        self._record_terminal_failure,
-                        seq,
-                        call_id,
-                        exc,
-                        iteration_index,
-                    )
-                raise
-            except Exception as exc:
-                result = {"error": str(exc)}
-            finally:
-                _active_idempotency_key.reset(token)
-            return await asyncio.to_thread(
-                self._record_result, seq, call_id, result, iteration_index
-            )
-
-        return execute
-
-    def finalize(self, outcome: str = "succeeded") -> None:
-        if not self._closed:
-            self.journal.close_run(self.run_id, outcome)
-            self._closed = True
-
-    def close(self) -> None:
-        self.journal.close()
-
-    async def arestore_messages(
-        self, messages: List[Dict[str, Any]]
-    ) -> List[Dict[str, Any]]:
-        return await asyncio.to_thread(self.restore_messages, messages)
-
-    async def afinalize(self, outcome: str = "succeeded") -> None:
-        await asyncio.to_thread(self.finalize, outcome)
-
-    async def aclose(self) -> None:
-        await asyncio.to_thread(self.close)
-
-
-def begin_durable_run(agent: Any, prompt: str):
-    """Create and activate a context, or return ``(None, None)`` when disabled."""
-    execution = getattr(agent, "execution", None)
-    if execution is None or not getattr(execution, "durable", False):
-        return None, None
-    if _active_durable_run.get() is not None:
-        return None, None
-
-    context = _open_durable_run(agent, prompt)
-    token = _active_durable_run.set(context)
-    return context, token
-
-
-def _open_durable_run(agent: Any, prompt: str) -> DurableRunContext:
-    """Open journal state without mutating the caller's ContextVar."""
-    execution = agent.execution
-
-    journal = RunJournal(getattr(execution, "journal_path", None))
-    resume_run_id = getattr(execution, "resume_run_id", None)
-    replaying = bool(resume_run_id)
-    run_id = str(resume_run_id or uuid4())
-
-    if replaying:
-        metadata = journal.run_meta(run_id)
-        if metadata is None:
-            journal.close()
-            raise ValueError(f"Cannot resume unknown durable run {run_id!r}")
-        if metadata.status != "running":
-            journal.close()
-            raise ValueError(
-                f"Cannot resume terminal durable run {run_id!r} "
-                f"(status={metadata.status!r})"
-            )
-        if metadata.task and metadata.task != prompt:
-            journal.close()
-            raise ValueError(
-                "Resume prompt does not match the prompt recorded for durable "
-                f"run {run_id!r}"
-            )
-
-    journal.open_run(
-        run_id,
-        agent=getattr(agent, "name", ""),
-        task=prompt,
-        metadata={"version": 1, "explicit_resume": replaying},
-    )
-    context = DurableRunContext(journal, run_id, replaying=replaying)
-    agent._last_durable_run_id = run_id
-    return context
-
-
-async def abegin_durable_run(agent: Any, prompt: str):
-    """Async durable-run creation with all SQLite I/O off the event loop."""
-    execution = getattr(agent, "execution", None)
-    if execution is None or not getattr(execution, "durable", False):
-        return None, None
-    if _active_durable_run.get() is not None:
-        return None, None
-    context = await asyncio.to_thread(_open_durable_run, agent, prompt)
-    token = _active_durable_run.set(context)
-    return context, token
-
-
-def end_durable_run(token) -> None:
-    if token is not None:
-        _active_durable_run.reset(token)
-
-
-def get_durable_run() -> Optional[DurableRunContext]:
-    return _active_durable_run.get()
-
-
-def get_durable_idempotency_key() -> Optional[str]:
-    """Return the stable key for the currently executing durable tool call."""
-    return _active_idempotency_key.get()

src/praisonai-agents/praisonaiagents/agent/execution_location.py

@@ -1,159 +0,0 @@
-"""Describe, in plain English, where an agent's work actually happens.
-
-PraisonAI can run the thinking (LLM calls) and the tools in different places:
-this machine, a container, or a provider's cloud. Which one you get depends on
-``run_on=``, ``backend=`` and ``sandbox=``, and until now none of that was
-visible from the object -- ``repr(agent)`` was the bare default.
-
-This module is the single source of that answer, shared by ``Agent``,
-``AgentTeam`` and ``AgentFlow`` so all three describe themselves identically.
-
-Vocabulary note: the fields are ``thinks_on`` / ``tools_run_on``, never
-``loop``. "Loop" is already a public workflow primitive here
-(``praisonaiagents.workflows.loop()``), asyncio's event loop, and agent-loop
-jargon a beginner would not know -- three meanings for one word is exactly the
-problem this module exists to fix.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, Optional
-
-# Provider name -> how a human would say it out loud.
-_PLACE_WORDS = {
-    "local": "this machine",
-    "subprocess": "a separate process on this machine",
-    "sandlock": "a locked-down process on this machine",
-    "docker": "a Docker container",
-    "e2b": "an E2B cloud sandbox",
-    "modal": "a Modal cloud sandbox",
-    "daytona": "a Daytona cloud sandbox",
-    "flyio": "a Fly.io machine",
-    "tenki": "a Tenki cloud sandbox",
-    "novita": "a Novita cloud sandbox",
-    "ssh": "a remote machine over SSH",
-    "anthropic": "Anthropic's cloud",
-}
-
-HERE = "this machine"
-
-# Public sandbox aliases the SandboxManager collapses before it picks a backend
-# (see praisonaiagents/sandbox/manager.py). We must describe the backend that
-# actually runs, not the alias the user typed, or "native"/"local" would report
-# a place that never executes.
-_ALIASES = {"native": "sandlock", "local": "subprocess"}
-
-# Tiers that separate a process but do NOT contain it. Verified: under the
-# subprocess backend, outbound network still works and ~/.ssh is readable even
-# though SecurityPolicy declares them blocked.
-_NOT_A_BOUNDARY = {"subprocess", "local", "native"}
-
-
-def say_place(name: Any) -> str:
-    """Turn a provider name into a phrase a non-developer can read."""
-    if name is None:
-        return HERE
-    if name is True:
-        return _PLACE_WORDS["subprocess"]
-    if not isinstance(name, str):
-        # A configured provider instance: use its own declared name if it has one.
-        name = getattr(name, "provider_name", None) or type(name).__name__
-    key = str(name).lower()
-    key = _ALIASES.get(key, key)
-    return _PLACE_WORDS.get(key, str(name))
-
-
-def _backend_places(backend: Any) -> Optional[Dict[str, str]]:
-    """Where does a managed ``backend=`` put the thinking and the tools?"""
-    if backend is None:
-        return None
-
-    cls = type(backend).__name__
-    # Hosted runtimes move the entire turn off this machine.
-    if "Hosted" in cls or "Anthropic" in cls:
-        provider = getattr(backend, "provider", None) or "anthropic"
-        where = say_place(provider)
-        return {"thinks_on": where, "tools_run_on": where}
-
-    # Local/sandboxed agents keep the loop here and may push tools out.
-    compute = getattr(backend, "_compute", None) or getattr(backend, "compute", None)
-    if compute is not None:
-        return {"thinks_on": HERE, "tools_run_on": say_place(compute)}
-    return {"thinks_on": HERE, "tools_run_on": HERE}
-
-
-def describe(obj: Any, *, shared: bool = False) -> Dict[str, str]:
-    """Return ``{thinks_on, tools_run_on, code_runs_on?}`` for an object.
-
-    Never raises: a description of where things run must not be able to break
-    the thing it describes.
-    """
-    places: Dict[str, str] = {"thinks_on": HERE, "tools_run_on": HERE}
-    try:
-        from_backend = _backend_places(getattr(obj, "backend", None))
-        if from_backend:
-            places.update(from_backend)
-
-        run_on = getattr(obj, "run_on", None)
-        if run_on is not None:
-            where = say_place(run_on)
-            places["tools_run_on"] = f"{where} (shared)" if shared else where
-
-        sandbox_config = getattr(obj, "sandbox_config", None)
-        if sandbox_config is not None:
-            places["code_runs_on"] = say_place(
-                getattr(sandbox_config, "sandbox_type", None)
-            )
-    except Exception:  # pragma: no cover - description must never break callers
-        pass
-    return places
-
-
-def repr_fields(obj: Any, *, shared: bool = False) -> str:
-    """Render the places as ``key='value'`` pairs for a ``__repr__``."""
-    return ", ".join(f"{k}={v!r}" for k, v in describe(obj, shared=shared).items())
-
-
-def explain(obj: Any, *, shared: bool = False) -> str:
-    """Plain-sentence answer to "where does this actually run?".
-
-    Deliberately uses only words a non-engineer already knows -- no "loop",
-    "harness", "provision" or "runtime".
-    """
-    places = describe(obj, shared=shared)
-    lines = [
-        f"Thinking (the AI model calls) happens on {places['thinks_on']}.",
-        f"Tools run on {places['tools_run_on']}.",
-    ]
-
-    if shared and getattr(obj, "run_on", None) is not None:
-        lines.append(
-            "Every step shares that same sandbox, so a file written by one step "
-            "is visible to the next."
-        )
-
-    if "code_runs_on" in places:
-        lines.append(
-            f"Code you run yourself with execute_code() runs on {places['code_runs_on']}."
-        )
-
-    # Say plainly when the chosen tier is not a security boundary.
-    raw = [
-        getattr(obj, "run_on", None),
-        getattr(getattr(obj, "sandbox_config", None), "sandbox_type", None),
-    ]
-    if any(isinstance(v, str) and v.lower() in _NOT_A_BOUNDARY for v in raw) or any(
-        v is True for v in raw
-    ):
-        lines.append(
-            "Note: a separate process is not a security boundary -- it can still "
-            "reach the network and read your files. Use docker or a cloud "
-            "provider for untrusted code."
-        )
-
-    if places["thinks_on"] == HERE and places["tools_run_on"] == HERE:
-        lines.append(
-            "Nothing is isolated: tools you pass run in this program, with your "
-            "permissions."
-        )
-    return "\n".join(lines)

src/praisonai-agents/praisonaiagents/agent/handoff.py

@@ -14,9 +14,9 @@ from typing import Optional, Any, Callable, Dict, List, Union, TYPE_CHECKING, Li
 from dataclasses import dataclass, field
 from enum import Enum
 import inspect
+import logging
 from praisonaiagents._logging import get_logger
 import asyncio
-import contextvars
 import threading
 import time
 import json
@@ -163,52 +163,33 @@ from ..errors import (
     HandoffValidationError
 )
 
-# Per-task/per-thread storage for tracking handoff chains.
-#
-# ``contextvars.ContextVar`` isolates the chain per :class:`asyncio.Task`
-# (and per OS thread), unlike ``threading.local()`` which shares one list
-# across every coroutine running on the same event-loop thread. Concurrent
-# async handoffs (``asyncio.gather``, a server handling parallel requests, or
-# any ``max_concurrent`` workflow) would otherwise push/pop into the same list
-# and corrupt each other's cycle/depth state. Combined with the copy-on-write
-# push/pop below, this fully isolates sibling handoff tasks (e.g. those spawned
-# by ``parallel_handoffs`` via ``asyncio.gather``).
-_handoff_chain_var: "contextvars.ContextVar[Optional[List[str]]]" = contextvars.ContextVar(
-    "handoff_chain", default=None
-)
+# Thread-local storage for tracking handoff chains
+_handoff_context = threading.local()
 
 def _get_handoff_chain() -> List[str]:
-    """Get current handoff chain for this task/thread."""
-    chain = _handoff_chain_var.get()
-    if chain is None:
-        chain = []
-        _handoff_chain_var.set(chain)
-    return chain
+    """Get current handoff chain from thread-local storage."""
+    if not hasattr(_handoff_context, 'chain'):
+        _handoff_context.chain = []
+    return _handoff_context.chain
 
 def _get_handoff_depth() -> int:
     """Get current handoff depth."""
     return len(_get_handoff_chain())
 
 def _push_handoff(agent_name: str) -> None:
-    """Push agent to handoff chain.
-
-    Uses copy-on-write so a push made inside a child task does not leak back
-    into the parent task's chain once the child completes.
-    """
-    chain = list(_get_handoff_chain())
+    """Push agent to handoff chain."""
+    chain = _get_handoff_chain()
     chain.append(agent_name)
-    _handoff_chain_var.set(chain)
 
 def _pop_handoff() -> Optional[str]:
     """Pop agent from handoff chain."""
-    chain = list(_get_handoff_chain())
-    popped = chain.pop() if chain else None
-    _handoff_chain_var.set(chain)
-    return popped
+    chain = _get_handoff_chain()
+    return chain.pop() if chain else None
 
 def _clear_handoff_chain() -> None:
     """Clear the handoff chain."""
-    _handoff_chain_var.set([])
+    if hasattr(_handoff_context, 'chain'):
+        _handoff_context.chain = []
 
 @dataclass
 class HandoffInputData:
@@ -308,14 +289,12 @@ class Handoff:
     - Cycle detection and depth limiting
     - Configurable context policies
     """
-
-    # Class-level lock guarding lazy creation of each instance's async
-    # semaphore. The semaphore itself is per-instance (so every Handoff
-    # enforces its own max_concurrent), but the brief init critical section is
-    # only ever touched under this shared threading.Lock, which keeps
-    # double-checked lazy creation thread-safe without a per-instance lock.
-    _semaphore_lock: threading.Lock = threading.Lock()
-
+    
+    # Class-level semaphore for concurrency control
+    _semaphore: Optional[asyncio.Semaphore] = None
+    _sync_semaphore: Optional[threading.Semaphore] = None
+    _semaphore_lock: threading.Lock = threading.Lock()  # Lock for semaphore initialization
+    
     def __init__(
         self,
         agent: 'Agent',
@@ -346,40 +325,10 @@ class Handoff:
         self.input_type = input_type
         self.input_filter = input_filter
         self.config = config or HandoffConfig()
-
-        # Instance-level concurrency control. Each Handoff enforces its own
-        # max_concurrent instead of sharing one process-wide semaphore, so
-        # different handoffs don't silently override each other's limits based
-        # on execution order. The async semaphore is created lazily (and
-        # recreated if bound to a stale event loop) since it binds to the
-        # running loop on first use.
-        self._semaphore: Optional[asyncio.Semaphore] = None
-        self._semaphore_loop: Optional[asyncio.AbstractEventLoop] = None
         
         # Override config callback if on_handoff provided directly
         if on_handoff and not self.config.on_handoff:
             self.config.on_handoff = on_handoff
-
-    def _get_semaphore(self) -> Optional[asyncio.Semaphore]:
-        """Return this handoff's async semaphore, bound to the current loop.
-
-        Returns None when concurrency limiting is disabled (max_concurrent <= 0).
-        The semaphore is created lazily and recreated if the running event loop
-        differs from the one it was originally bound to, so a process that calls
-        asyncio.run(...) more than once doesn't crash with a "bound to a
-        different event loop" RuntimeError.
-        """
-        if self.config.max_concurrent <= 0:
-            return None
-        try:
-            current_loop = asyncio.get_event_loop()
-        except RuntimeError:
-            current_loop = None
-        with self._semaphore_lock:
-            if self._semaphore is None or self._semaphore_loop is not current_loop:
-                self._semaphore = asyncio.Semaphore(self.config.max_concurrent)
-                self._semaphore_loop = current_loop
-            return self._semaphore
         
     @property
     def tool_name(self) -> str:
@@ -648,15 +597,13 @@ class Handoff:
         """
         start_time = time.time()
         kwargs = context or {}
-        pushed = False
         
         try:
-            # Safety checks (may raise before anything is pushed for this call)
+            # Safety checks
             self._check_safety(source_agent)
             
             # Track handoff chain
             _push_handoff(source_agent.name)
-            pushed = True
             
             # Execute on_handoff callback
             self._execute_callback(self.config.on_handoff or self.on_handoff, source_agent, kwargs)
@@ -732,8 +679,7 @@ class Handoff:
             logger.error(f"Handoff error: {e}")
             return result
         finally:
-            if pushed:
-                _pop_handoff()
+            _pop_handoff()
     
     async def execute_async(
         self,
@@ -752,19 +698,20 @@ class Handoff:
         Returns:
             HandoffResult with response or error
         """
-        # Per-instance semaphore, bound to the current event loop
-        semaphore = self._get_semaphore()
+        # Initialize semaphore if needed (thread-safe)
+        if self.config.max_concurrent > 0 and Handoff._semaphore is None:
+            with Handoff._semaphore_lock:  # Thread-safe initialization
+                if Handoff._semaphore is None:  # Double-check after acquiring lock
+                    Handoff._semaphore = asyncio.Semaphore(self.config.max_concurrent)
         
         start_time = time.time()
         kwargs = context or {}
         
         async def _execute():
-            pushed = False
             try:
-                # Safety checks (may raise before anything is pushed for this call)
+                # Safety checks
                 self._check_safety(source_agent)
                 _push_handoff(source_agent.name)
-                pushed = True
                 
                 # Execute callback
                 self._execute_callback(self.config.on_handoff or self.on_handoff, source_agent, kwargs)
@@ -813,12 +760,11 @@ class Handoff:
                 
                 return result
             finally:
-                if pushed:
-                    _pop_handoff()
+                _pop_handoff()
         
         try:
-            if semaphore is not None:
-                async with semaphore:
+            if self.config.max_concurrent > 0 and Handoff._semaphore:
+                async with Handoff._semaphore:
                     if self.config.timeout_seconds > 0:
                         result = await asyncio.wait_for(
                             _execute(),
@@ -882,15 +828,13 @@ class Handoff:
         def handoff_tool(**kwargs):
             """Execute the handoff to the target agent."""
             start_time = time.time()
-            pushed = False
             
             try:
-                # Safety checks (may raise before anything is pushed for this call)
+                # Safety checks
                 self._check_safety(source_agent)
                 
                 # Track handoff chain
                 _push_handoff(source_agent.name)
-                pushed = True
                 
                 # Execute on_handoff callback
                 self._execute_callback(self.config.on_handoff or self.on_handoff, source_agent, kwargs)
@@ -976,8 +920,7 @@ class Handoff:
                 self._execute_callback(self.config.on_error, source_agent, kwargs, result)
                 return f"Error during handoff to {self.agent.name}: {str(e)}"
             finally:
-                if pushed:
-                    _pop_handoff()
+                _pop_handoff()
         
         # Set function metadata for tool definition generation
         handoff_tool.__name__ = self.tool_name
@@ -1228,13 +1171,6 @@ async def parallel_handoffs(
     semaphore = asyncio.Semaphore(effective_max_concurrent) if effective_max_concurrent > 0 else None
     
     async def _run_one(agent, prompt):
-        # Each gathered task shares a copied context, but a copied ContextVar
-        # binding still points at the *same* parent list object. Rebind to a
-        # fresh, per-task copy so sibling handoffs cannot corrupt each other's
-        # cycle/depth tracking when parallel_handoffs runs inside a non-empty
-        # parent handoff chain.
-        _handoff_chain_var.set(list(_handoff_chain_var.get() or []))
-
         async def _do_handoff():
             try:
                 return await source.handoff_to_async(agent, prompt, config=config)
@@ -1455,15 +1391,13 @@ class TypedHandoff(Handoff, Generic[T]):
         
         start_time = time.time()
         kwargs = context or {}
-        pushed = False
         
         try:
-            # Safety checks (may raise before anything is pushed for this call)
+            # Safety checks
             self._check_safety(source_agent)
             
             # Track handoff chain
             _push_handoff(source_agent.name)
-            pushed = True
             
             # Execute on_handoff callback
             self._execute_callback(self.config.on_handoff or self.on_handoff, source_agent, kwargs)
@@ -1536,8 +1470,7 @@ class TypedHandoff(Handoff, Generic[T]):
             logger.error(f"Typed handoff error: {e}")
             return result
         finally:
-            if pushed:
-                _pop_handoff()
+            _pop_handoff()
     
     async def execute_async(
         self,
@@ -1564,19 +1497,20 @@ class TypedHandoff(Handoff, Generic[T]):
         if isinstance(payload, str):
             return await super().execute_async(source_agent, payload, context)
         
-        # Per-instance semaphore, bound to the current event loop
-        semaphore = self._get_semaphore()
+        # Initialize semaphore if needed (thread-safe)
+        if self.config.max_concurrent > 0 and Handoff._semaphore is None:
+            with Handoff._semaphore_lock:
+                if Handoff._semaphore is None:
+                    Handoff._semaphore = asyncio.Semaphore(self.config.max_concurrent)
         
         start_time = time.time()
         kwargs = context or {}
         
         async def _execute():
-            pushed = False
             try:
-                # Safety checks (may raise before anything is pushed for this call)
+                # Safety checks
                 self._check_safety(source_agent)
                 _push_handoff(source_agent.name)
-                pushed = True
                 
                 # Execute callback
                 self._execute_callback(self.config.on_handoff or self.on_handoff, source_agent, kwargs)
@@ -1624,12 +1558,11 @@ class TypedHandoff(Handoff, Generic[T]):
                     handoff_depth=_get_handoff_depth(),
                 )
             finally:
-                if pushed:
-                    _pop_handoff()
+                _pop_handoff()
         
         try:
-            if semaphore is not None:
-                async with semaphore:
+            if self.config.max_concurrent > 0 and Handoff._semaphore:
+                async with Handoff._semaphore:
                     if self.config.timeout_seconds > 0:
                         result = await asyncio.wait_for(
                             _execute(),